Migrated from GitHub

.gitattributes

@@ -57,3 +57,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/data/dataset.json filter=lfs diff=lfs merge=lfs -text

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Peter Mikhael
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/configs/protein_localization/eval_full_prot.json

@@ -0,0 +1,11 @@
+{
+    "script": "main",
+    "train_config": "configs/protein_localization/full_prot_comp_pred.json",
+    "log_dir": "protgps/logs/",
+    "available_gpus": ["0,1,2,3,4,5,6,7"],
+    "eval_args": {
+      "test": [true],
+      "from_checkpoint": [true],
+      "checkpoint_path": ["checkpoints/prtogps/32bf44b16a4e770a674896b81dfb3729epoch=26.ckpt"]
+    }
+}

data/configs/protein_localization/full_prot_comp_pred.json

@@ -0,0 +1,55 @@
+{
+  "script": "main",
+  "paired_hyperparams": {
+    "dataset_name": ["protein_condensates_combined"],
+    "protein_encoder_type": ["fair_esm_fast"]
+  },
+  "cartesian_hyperparams": {
+    "batch_size": [10],
+    "freeze_encoder": [false],
+    "freeze_esm": [false],
+    "logger_tags": ["full_prot_pred"],
+    "max_prot_len": [1800],
+    "accumulate_grad_batches": [1],
+    "precision": [16],
+    "dataset_file_path": ["data/dataset.json"],
+    "assign_splits": [true],
+    "split_seed": [0],
+    "split_probs": ["0.7 0.15 0.15"],
+    "lightning_name": ["base"],
+    "weight_decay": [0],
+    "momentum": [0.9],
+    "max_epochs": [30],
+    "lr_decay": [0.91],
+    "scheduler_name": ["reduce_on_plateau"],
+    "lr": [1e-3],
+    "model_name": ["protein_encoder"],
+    "pretrained_hub_dir": ["checkpoints/esm2"],
+    "output_residue_hiddens": [true],
+    "esm_hidden_layer": [6],
+    "esm_name": ["esm2_t6_8M_UR50D"],
+    "protein_hidden_dim" : [320],
+    "mlp_layer_configuration": ["512 512"],
+    "mlp_use_batch_norm": [true],
+    "loss_names": ["binary_cross_entropy"],
+    "metric_names": ["multilabel_classification"],
+    "checkpoint_dir": ["checkpoints/protgps"],
+    "checkpoint_save_last": [true],
+    "monitor": ["val_roc_auc"],
+    "num_workers": [30],
+    "optimizer_name": ["adam"],
+    "patience": [5],
+    "train": [true],
+    "dev": [true],
+    "test": [true],
+    "callback_names": ["checkpointer lr_monitor"],
+    "num_sanity_val_steps": [0],
+    "profiler": ["simple"],
+    "logger_name": ["tensorboard"],
+    "gpus": [1],
+    "val_check_interval": [1.0],
+    "ignore_warnings": [false],
+    "dropout": [0.1]
+  },
+  "available_gpus": ["0"]
+}

data/data/dataset.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:02c2cf66a58f5ed3a30650da9d9d9b71c2b0700005e93aac48c7ef7bc9f05d60
+size 13875542

data/environment.yml

@@ -0,0 +1,133 @@
+name: protgps
+channels:
+  - pytorch
+  - nvidia
+  - conda-forge
+  - defaults
+dependencies:
+  - _libgcc_mutex=0.1=conda_forge
+  - _openmp_mutex=4.5=2_gnu
+  - blas=2.16=mkl
+  - bzip2=1.0.8=hd590300_5
+  - ca-certificates=2024.2.2=hbcca054_0
+  - captum==0.7.0
+  - cuda-cudart=11.7.99=0
+  - cuda-cupti=11.7.101=0
+  - cuda-libraries=11.7.1=0
+  - cuda-nvrtc=11.7.99=0
+  - cuda-nvtx=11.7.91=0
+  - cuda-runtime=11.7.1=0
+  - filelock=3.13.1=pyhd8ed1ab_0
+  - gmp=6.3.0=h59595ed_0
+  - gmpy2=2.1.2=py38h793c122_1
+  - intel-openmp=2023.1.0=hdb19cb5_46306
+  - jinja2=3.1.3=pyhd8ed1ab_0
+  - ld_impl_linux-64=2.40=h41732ed_0
+  - libblas=3.8.0=16_mkl
+  - libcblas=3.8.0=16_mkl
+  - libcublas=11.10.3.66=0
+  - libcufft=10.7.2.124=h4fbf590_0
+  - libcufile=1.8.1.2=0
+  - libcurand=10.3.4.107=0
+  - libcusolver=11.4.0.1=0
+  - libcusparse=11.7.4.91=0
+  - libffi=3.4.2=h7f98852_5
+  - libgcc-ng=13.2.0=h807b86a_5
+  - libgfortran-ng=7.5.0=h14aa051_20
+  - libgfortran4=7.5.0=h14aa051_20
+  - libgomp=13.2.0=h807b86a_5
+  - liblapack=3.8.0=16_mkl
+  - liblapacke=3.8.0=16_mkl
+  - libnpp=11.7.4.75=0
+  - libnsl=2.0.1=hd590300_0
+  - libnvjpeg=11.8.0.2=0
+  - libsqlite=3.45.1=h2797004_0
+  - libstdcxx-ng=13.2.0=h7e041cc_5
+  - libuuid=2.38.1=h0b41bf4_0
+  - libzlib=1.2.13=hd590300_5
+  - markupsafe=2.1.5=py38h01eb140_0
+  - mkl=2020.2=256
+  - mpc=1.3.1=hfe3b2da_0
+  - mpfr=4.2.1=h9458935_0
+  - mpmath=1.3.0=pyhd8ed1ab_0
+  - ncurses=6.4=h59595ed_2
+  - networkx=3.1=pyhd8ed1ab_0
+  - openssl=3.2.1=hd590300_0
+  - pip=24.0=pyhd8ed1ab_0
+  - python=3.8.15=he550d4f_1_cpython
+  - python_abi=3.8=4_cp38
+  - pytorch=2.0.0=py3.8_cuda11.7_cudnn8.5.0_0
+  - pytorch-cuda=11.7=h778d358_5
+  - pytorch-mutex=1.0=cuda
+  - readline=8.2=h8228510_1
+  - setuptools=69.1.0=pyhd8ed1ab_1
+  - sympy=1.12=pypyh9d50eac_103
+  - torchtriton=2.0.0=py38
+  - typing_extensions=4.9.0=pyha770c72_0
+  - wheel=0.42.0=pyhd8ed1ab_0
+  - xz=5.2.6=h166bdaf_0
+  - zlib=1.2.13=hd590300_5
+  - pip:
+      - absl-py==2.1.0
+      - cachetools==5.3.2
+      - certifi==2024.2.2
+      - charset-normalizer==3.3.2
+      - click==8.1.7
+      - comet-ml==3.28.1
+      - configobj==5.0.8
+      - docker-pycreds==0.4.0
+      - dulwich==0.21.7
+      - everett==3.3.0
+      - gitdb==4.0.11
+      - gitpython==3.1.42
+      - google-auth==2.28.1
+      - google-auth-oauthlib==1.0.0
+      - grpcio==1.62.0
+      - idna==3.6
+      - importlib-metadata==7.0.1
+      - importlib-resources==6.1.1
+      - joblib==1.3.2
+      - markdown==3.5.2
+      - numpy==1.23.4
+      - nvidia-ml-py3==7.352.0
+      - oauthlib==3.2.2
+      - openpyxl==3.1.2
+      - packaging==23.2
+      - pandas==2.0.3
+      - pathtools==0.1.2
+      - pillow==10.2.0
+      - pkgutil-resolve-name==1.3.10
+      - promise==2.3
+      - protobuf==3.20.1
+      - protpy==1.2.1
+      - psutil==5.9.8
+      - pyasn1==0.5.1
+      - pyasn1-modules==0.3.0
+      - pydeprecate==0.3.2
+      - python-dateutil==2.8.2
+      - pytorch-lightning==1.6.4
+      - pytz==2024.1
+      - pyyaml==6.0.1
+      - rdkit==2022.9.5
+      - requests-oauthlib==1.3.1
+      - requests-toolbelt==1.0.0
+      - rsa==4.9
+      - scikit-learn==1.0.1
+      - scipy==1.10.1
+      - semantic-version==2.10.0
+      - sentry-sdk==1.40.5
+      - setproctitle==1.3.3
+      - shortuuid==1.0.11
+      - six==1.16.0
+      - smmap==5.0.1
+      - tensorboard==2.14.0
+      - tensorboard-data-server==0.7.2
+      - threadpoolctl==3.3.0
+      - tqdm==4.62.3
+      - urllib3==2.2.1
+      - wandb==0.12.19
+      - websocket-client==1.7.0
+      - werkzeug==3.0.1
+      - wrapt==1.16.0
+      - wurlitzer==3.0.3
+      - zipp==3.17.0

data/protgps/__init__.py

@@ -0,0 +1,51 @@
+# type: ignore
+
+import sys
+
+if sys.version_info[:2] >= (3, 8):
+    # TODO: Import directly (no need for conditional) when `python_requires = >= 3.8`
+    from importlib.metadata import PackageNotFoundError, version  # pragma: no cover
+else:
+    from importlib_metadata import PackageNotFoundError, version  # pragma: no cover
+
+try:
+    # Change here if project is renamed and does not equal the package name
+    dist_name = __name__
+    __version__ = version(dist_name)
+except PackageNotFoundError:  # pragma: no cover
+    __version__ = "unknown"
+finally:
+    del version, PackageNotFoundError
+
+
+# data
+import protgps.datasets.protein_compartments
+import protgps.datasets.reverse_homology
+
+# lightning
+import protgps.lightning.base
+
+# optimizers
+import protgps.learning.optimizers.basic
+
+# scheduler
+import protgps.learning.schedulers.basic
+
+# losses
+import protgps.learning.losses.basic
+
+# metrics
+import protgps.learning.metrics.basic
+
+# callbacks
+import protgps.callbacks.basic
+import protgps.callbacks.swa
+
+# models
+import protgps.models.classifier
+import protgps.models.fair_esm
+
+# comet
+import protgps.loggers.comet
+import protgps.loggers.wandb
+import protgps.loggers.tensorboard

data/protgps/callbacks/basic.py

@@ -0,0 +1,26 @@
+import os
+from protgps.utils.registry import register_object
+from protgps.utils.classes import ProtGPS
+from pytorch_lightning.callbacks import ModelCheckpoint, LearningRateMonitor
+
+# TODO: add args for various callbacks -- currently hardcoded
+
+
+@register_object("checkpointer", "callback")
+class Checkpoint(ModelCheckpoint, ProtGPS):
+    def __init__(self, args) -> None:
+        super().__init__(
+            monitor=args.monitor,
+            dirpath=os.path.join(args.checkpoint_dir, args.experiment_name),
+            mode="min" if "loss" in args.monitor else "max",
+            filename="{}".format(args.experiment_name) + "{epoch}",
+            every_n_epochs=1,
+            save_top_k=args.checkpoint_save_top_k,
+            save_last=args.checkpoint_save_last,
+        )
+
+
+@register_object("lr_monitor", "callback")
+class LRMonitor(LearningRateMonitor, ProtGPS):
+    def __init__(self, args) -> None:
+        super().__init__(logging_interval="step")

data/protgps/callbacks/swa.py

@@ -0,0 +1,55 @@
+from protgps.utils.registry import register_object
+from pytorch_lightning.callbacks import StochasticWeightAveraging
+from protgps.utils.classes import ProtGPS
+
+
+@register_object("swa", "callback")
+class SWA(StochasticWeightAveraging, ProtGPS):
+    def __init__(self, args) -> None:
+        if "." in args.swa_epoch:
+            swa_epoch = float(args.swa_epoch)
+        else:
+            swa_epoch = int(args.swa_epoch)
+
+        super().__init__(
+            swa_epoch_start=swa_epoch,
+            swa_lrs=args.swa_lr,
+            annealing_epochs=args.swa_annealing_epochs,
+            annealing_strategy=args.swa_annealing_strategy,
+            avg_fn=None,
+        )
+
+    @staticmethod
+    def add_args(parser) -> None:
+        """Add class specific args
+
+        Args:
+            parser (argparse.ArgumentParser): argument parser
+        """
+        # stochastic weight averaging
+        parser.add_argument(
+            "--swa_epoch",
+            type=str,
+            default="0.8",
+            help="when to start swa",
+        )
+
+        parser.add_argument(
+            "--swa_lr",
+            type=float,
+            default=None,
+            help="lr for swa. None will use existing lr",
+        )
+        parser.add_argument(
+            "--swa_annealing_epochs",
+            type=int,
+            default=10,
+            help="number of epochs in the annealing phase",
+        )
+        parser.add_argument(
+            "--swa_annealing_strategy",
+            type=str,
+            choices=["cos", "linear"],
+            default="cos",
+            help="lr annealing strategy",
+        )

data/protgps/datasets/abstract.py

@@ -0,0 +1,271 @@
+import traceback, warnings
+import argparse
+from typing import List, Literal
+from abc import ABCMeta, abstractmethod
+import json
+from collections import Counter
+import numpy as np
+from torch.utils import data
+from protgps.utils.classes import ProtGPS, set_protgps_type, classproperty
+from protgps.utils.messages import METAFILE_NOTFOUND_ERR, LOAD_FAIL_MSG
+import pickle
+
+
+class AbstractDataset(data.Dataset, ProtGPS):
+    def __init__(self, args: argparse.ArgumentParser, split_group: str) -> None:
+        """
+        Abstract Dataset
+        params: args - config.
+        params: split_group - ['train'|'dev'|'test'].
+
+        constructs: standard pytorch Dataset obj, which can be fed in a DataLoader for batching
+        """
+        __metaclass__ = ABCMeta
+
+        super(AbstractDataset, self).__init__()
+
+        self.split_group = split_group
+        self.args = args
+
+        self.init_class(args, split_group)
+
+        self.dataset = self.create_dataset(split_group)
+        if len(self.dataset) == 0:
+            return
+
+        self.set_sample_weights(args)
+
+        self.print_summary_statement(self.dataset, split_group)
+
+    def init_class(self, args: argparse.ArgumentParser, split_group: str) -> None:
+        """Perform Class-Specific init methods
+           Default is to load JSON dataset
+
+        Args:
+            args (argparse.ArgumentParser)
+            split_group (str)
+        """
+        self.load_dataset(args)
+
+    def load_dataset(self, args: argparse.ArgumentParser) -> None:
+        """Loads dataset file
+
+        Args:
+            args (argparse.ArgumentParser)
+
+        Raises:
+            Exception: Unable to load
+        """
+        try:
+            self.metadata_json = json.load(open(args.dataset_file_path, "r"))
+        except Exception as e:
+            raise Exception(METAFILE_NOTFOUND_ERR.format(args.dataset_file_path, e))
+
+    @abstractmethod
+    def create_dataset(
+        self, split_group: Literal["train", "dev", "test"]
+    ) -> List[dict]:
+        """
+        Creates the dataset of samples from json metadata file.
+        """
+        pass
+
+    @abstractmethod
+    def skip_sample(self, sample) -> bool:
+        """
+        Return True if sample should be skipped and not included in data
+        """
+        return False
+
+    @abstractmethod
+    def check_label(self, sample) -> bool:
+        """
+        Return True if the row contains a valid label for the task
+        """
+        pass
+
+    @abstractmethod
+    def get_label(self, sample):
+        """
+        Get task specific label for a given sample
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def SUMMARY_STATEMENT(self) -> None:
+        """
+        Prints summary statement with dataset stats
+        """
+        pass
+
+    def print_summary_statement(self, dataset, split_group):
+        statement = "{} DATASET CREATED FOR {}.\n{}".format(
+            split_group.upper(), self.args.dataset_name.upper(), self.SUMMARY_STATEMENT
+        )
+        print(statement)
+
+    def __len__(self) -> int:
+        return len(self.dataset)
+
+    @abstractmethod
+    def __getitem__(self, index):
+        """
+        Fetch single sample from dataset
+
+        Args:
+            index (int): random index of sample from dataset
+
+        Returns:
+            sample (dict): a sample
+        """
+        sample = self.dataset[index]
+        try:
+            return sample
+        except Exception:
+            warnings.warn(
+                LOAD_FAIL_MSG.format(sample["sample_id"], traceback.print_exc())
+            )
+
+    def assign_splits(self, metadata_json, split_probs, seed=0) -> None:
+        """
+        Assign samples to data splits
+
+        Args:
+            metadata_json (dict): raw json dataset loaded
+        """
+        np.random.seed(seed)
+        if self.args.split_type == "random":
+            for idx in range(len(metadata_json)):
+                if metadata_json[idx] is None:
+                    continue
+                metadata_json[idx]["split"] = np.random.choice(
+                    ["train", "dev", "test"], p=split_probs
+                )
+        elif self.args.split_type == "mmseqs":
+            # mmseqs easy-cluster --min-seq-id 0.3 -c 0.8
+            # get all samples
+            to_split = {}
+
+            row2clust = pickle.load(
+                open(
+                    "data/mmseqs_row2cluster_30seq_80cov.p",
+                    "rb",
+                )
+            )
+            # rule id
+            clusters = list(row2clust.values())
+            clust2count = Counter(clusters)
+            samples = sorted(list(set(clusters)))
+            np.random.shuffle(samples)
+            samples_cumsum = np.cumsum([clust2count[s] for s in samples])
+            # Find the indices for each quantile
+            split_indices = [
+                np.searchsorted(
+                    samples_cumsum, np.round(q, 3) * samples_cumsum[-1], side="right"
+                )
+                for q in np.cumsum(split_probs)
+            ]
+            split_indices[-1] = len(samples)
+            split_indices = np.concatenate([[0], split_indices])
+            for i in range(len(split_indices) - 1):
+                to_split.update(
+                    {
+                        sample: ["train", "dev", "test"][i]
+                        for sample in samples[split_indices[i] : split_indices[i + 1]]
+                    }
+                )
+            for idx in range(len(metadata_json)):
+                metadata_json[idx]["split"] = to_split[row2clust[idx]]
+
+    def set_sample_weights(self, args: argparse.ArgumentParser) -> None:
+        """
+        Set weights for each sample
+
+        Args:
+            args (argparse.ArgumentParser)
+        """
+        if args.class_bal:
+            label_dist = [str(d[args.class_bal_key]) for d in self.dataset]
+            label_counts = Counter(label_dist)
+            weight_per_label = 1.0 / len(label_counts)
+            label_weights = {
+                label: weight_per_label / count for label, count in label_counts.items()
+            }
+
+            print("Class counts are: {}".format(label_counts))
+            print("Label weights are {}".format(label_weights))
+            self.weights = [
+                label_weights[str(d[args.class_bal_key])] for d in self.dataset
+            ]
+        else:
+            pass
+
+    @classproperty
+    def DATASET_ITEM_KEYS(cls) -> list:
+        """
+        List of keys to be included in sample when being batched
+
+        Returns:
+            list
+        """
+        standard = ["sample_id"]
+        return standard
+
+    @staticmethod
+    def add_args(parser) -> None:
+        """Add class specific args
+
+        Args:
+            parser (argparse.ArgumentParser): argument parser
+        """
+        parser.add_argument(
+            "--class_bal", action="store_true", default=False, help="class balance"
+        )
+        parser.add_argument(
+            "--class_bal_key",
+            type=str,
+            default="y",
+            help="dataset key to use for class balancing",
+        )
+        parser.add_argument(
+            "--dataset_file_path",
+            type=str,
+            default=None,
+            help="Path to dataset file",
+        )
+        parser.add_argument(
+            "--data_dir",
+            type=str,
+            default=None,
+            help="Path to dataset directory",
+        )
+        parser.add_argument(
+            "--num_classes", type=int, default=6, help="Number of classes to predict"
+        )
+        # Alternative training/testing schemes
+        parser.add_argument(
+            "--assign_splits",
+            action="store_true",
+            default=False,
+            help="Whether to assign different splits than those predetermined in dataset",
+        )
+        parser.add_argument(
+            "--split_type",
+            type=str,
+            default="random",
+            help="How to split dataset if assign_split = True..",
+        )
+        parser.add_argument(
+            "--split_probs",
+            type=float,
+            nargs="+",
+            default=[0.6, 0.2, 0.2],
+            help="Split probs for datasets without fixed train dev test. ",
+        )
+        parser.add_argument(
+            "--split_seed",
+            type=int,
+            default=0,
+            help="seed for consistent randomization",
+        )

data/protgps/datasets/disprot.py

@@ -0,0 +1,169 @@
+# dataset utils
+from random import sample
+import warnings
+from typing import Literal, List
+from protgps.datasets.abstract import AbstractDataset
+from protgps.utils.registry import register_object, get_object
+from protgps.utils.classes import set_protgps_type
+from tqdm import tqdm
+import argparse
+import torch
+
+
+@register_object("disprot", "dataset")
+class Disprot(AbstractDataset):
+    """A pytorch Dataset for the classifying protein intrinsically disordered regions from Disprot DB."""
+
+    def init_class(self, args: argparse.ArgumentParser, split_group: str) -> None:
+        """Perform Class-Specific init methods
+           Default is to load JSON dataset
+
+        Args:
+            args (argparse.ArgumentParser)
+            split_group (str)
+        """
+        self.load_dataset(args)
+        if args.assign_splits:
+            self.assign_splits(
+                self.metadata_json, split_probs=args.split_probs, seed=args.split_seed
+            )
+        
+        if args.precomputed_protein_embeddings:
+            self.protein_encoder = get_object(self.args.protein_encoder_name, "model")(
+                args
+            ).to("cuda")
+            self.protein_encoder.eval()
+
+    def skip_sample(self, sample, split_group) -> bool:
+        """
+        Return True if sample should be skipped and not included in data
+        """
+        if sample["split"] != split_group:
+            return True
+        return False
+
+    def create_dataset(
+        self, split_group: Literal["train", "dev", "test"]
+    ) -> List[dict]:
+
+        sequences = []
+        dataset = []
+        for protein_dict in tqdm(self.metadata_json["data"]):
+            if self.skip_sample(protein_dict, split_group):
+                continue
+
+            item = {
+                "x": protein_dict["sequence"],
+                "y": self.get_label(sample_dict),
+                "sample_id": protein_dict["disprot_id"],
+            }
+            sequences.append(protein_dict["sequence"])
+            dataset.append(item)
+
+        
+        if args.precomputed_protein_embeddings:
+            # this batches protein sequences and then converts to features
+            batch_size = 10
+            hiddens = []
+            for i in tqdm(range(0, len(ids), batch_size)):
+                preds = self.protein_encoder(sequences[i : i + batch_size])
+                hiddens.append( preds["hidden"].cpu() )
+            hiddens = torch.stack(hiddens)
+            
+            for i, h in enumerate(hiddens):
+                dataset[i]["sequence"] = dataset[i]["x"]
+                dataset[i]["x"] = h
+
+        return dataset
+
+    def get_label(self, protein_dict):
+        """
+        Get task specific label for a given sample
+        """
+        y = torch.zeros(len(protein_dict["sequence"]))
+        for disordered_region in protein_dict["regions"]:
+            start = disordered_region["start"] - 1
+            end = disordered_region["end"]
+            y[start:end] = 1
+        return y
+
+    def __getitem__(self, index):
+        try:
+            return self.dataset[index]
+
+        except Exception:
+            warnings.warn("Could not load sample")
+
+    @property
+    def SUMMARY_STATEMENT(self) -> None:
+        """
+        Prints summary statement with dataset stats
+        """
+        return f"{len(self.dataset)} Proteins."
+
+    @staticmethod
+    def set_args(args) -> None:
+        args.num_classes = 1
+    
+
+    @staticmethod
+    def add_args(parser) -> None:
+        """Add class specific args
+
+        Args:
+            parser (argparse.ArgumentParser): argument parser
+        """
+        super(Disprot, Disprot).add_args(parser)
+        parser.add_argument(
+            "--precomputed_protein_embeddings",
+            default=False,
+            action="store_true",        
+            help="whether to use precomputed embeddings",
+        )
+
+
+
+@register_object("protein_compartment_precomputed", "dataset")
+class Protein_Compartments_Precomputed(Protein_Compartments):
+    """A pytorch Dataset for the classifying proteins into compartment."""
+
+
+    def create_dataset(
+        self, split_group: Literal["train", "dev", "test"]
+    ) -> List[dict]:
+
+        dataset = []
+        for sample_dict in tqdm(self.metadata_json):
+            if self.skip_sample(sample_dict, split_group):
+                continue
+
+            item = {
+                "sequence": sample_dict["Sequence"],
+                "x": torch.tensor(sample_dict["esm2_embedding"]),
+                "y": self.get_label(sample_dict),
+                "sample_id": sample_dict["Entry"],
+            }
+            dataset.append(item)
+        
+
+        return dataset
+
+    @staticmethod
+    def set_args(args) -> None:
+        args.num_classes = 5
+        args.mlp_input_dim = args.protein_hidden_dim
+
+    @staticmethod
+    def add_args(parser) -> None:
+        """Add class specific args
+
+        Args:
+            parser (argparse.ArgumentParser): argument parser
+        """
+        super(Protein_Compartments_Precomputed, Protein_Compartments_Precomputed).add_args(parser)
+        parser.add_argument(
+            "--protein_hidden_dim",
+            type=int,
+            default=1280,
+            help="hidden dimension of the protein",
+        )

data/protgps/datasets/protein_compartments.py

@@ -0,0 +1,412 @@
+# dataset utils
+import warnings
+from typing import Literal, List
+from protgps.datasets.abstract import AbstractDataset
+from protgps.utils.registry import register_object
+from tqdm import tqdm
+import argparse
+import torch
+
+
+@register_object("protein_compartment", "dataset")
+class Protein_Compartments(AbstractDataset):
+    """A pytorch Dataset for the classifying proteins into compartment."""
+
+    def init_class(self, args: argparse.ArgumentParser, split_group: str) -> None:
+        """Perform Class-Specific init methods
+           Default is to load JSON dataset
+
+        Args:
+            args (argparse.ArgumentParser)
+            split_group (str)
+        """
+        self.load_dataset(args)
+        if args.assign_splits:
+            self.assign_splits(
+                self.metadata_json, split_probs=args.split_probs, seed=args.split_seed
+            )
+
+    @property
+    def COMPARTMENTS(self):
+        return ["cytosol", "nucleoli", "nucleoplasm", "ER", "mitochondria"]
+
+    def skip_sample(self, sample, split_group) -> bool:
+        """
+        Return True if sample should be skipped and not included in data
+        """
+        if sample["split"] != split_group:
+            return True
+        if "Sequence" in sample and len(sample["Sequence"]) < 10:
+            return True
+        if "sequence" in sample and len(sample["sequence"]) < 10:
+            return True
+
+        if "Sequence" in sample and len(sample["Sequence"]) > self.args.max_prot_len:
+            return True
+        if "sequence" in sample and len(sample["sequence"]) > self.args.max_prot_len:
+            return True
+
+        return False
+
+    def create_dataset(
+        self, split_group: Literal["train", "dev", "test"]
+    ) -> List[dict]:
+        dataset = []
+        for sample_dict in tqdm(self.metadata_json):
+            if self.skip_sample(sample_dict, split_group):
+                continue
+
+            item = {
+                "x": sample_dict["Sequence"],
+                "y": self.get_label(sample_dict),
+                "sample_id": sample_dict["Entry"],
+            }
+            dataset.append(item)
+        return dataset
+
+    def get_label(self, sample):
+        """
+        Get task specific label for a given sample
+        """
+        try:
+            return torch.tensor([sample[c] for c in self.COMPARTMENTS])
+        except:
+            return None
+
+    def __getitem__(self, index):
+        try:
+            return self.dataset[index]
+
+        except Exception:
+            warnings.warn("Could not load sample")
+
+    @property
+    def SUMMARY_STATEMENT(self) -> None:
+        """
+        Prints summary statement with dataset stats
+        """
+        try:
+            compartment_counts = (
+                torch.stack([d["y"] for d in self.dataset]).sum(0).tolist()
+            )
+            compartment_str = ""
+            for i, (c, count) in enumerate(zip(self.COMPARTMENTS, compartment_counts)):
+                compartment_str += f"{count} {c.upper()}"
+                if i < len(self.COMPARTMENTS) - 1:
+                    compartment_str += " -- "
+            return f"* {len(self.dataset)} Proteins.\n* {compartment_str}"
+        except:
+            return "Could not produce summary statement"
+
+    @staticmethod
+    def set_args(args) -> None:
+        args.num_classes = 5
+
+    @staticmethod
+    def add_args(parser) -> None:
+        """Add class specific args
+
+        Args:
+            parser (argparse.ArgumentParser): argument parser
+        """
+        super(Protein_Compartments, Protein_Compartments).add_args(parser)
+        parser.add_argument(
+            "--max_prot_len",
+            type=int,
+            default=2000,
+            help="len above which to skip prots",
+        )
+
+
+@register_object("protein_compartment_guy", "dataset")
+class ProteinCompartmentsGuy(AbstractDataset):
+    """A pytorch Dataset for the classifying proteins into compartment."""
+
+    def init_class(self, args: argparse.ArgumentParser, split_group: str) -> None:
+        """Perform Class-Specific init methods
+           Default is to load JSON dataset
+
+        Args:
+            args (argparse.ArgumentParser)
+            split_group (str)
+        """
+        self.load_dataset(args)
+        if args.assign_splits:
+            self.assign_splits(
+                self.metadata_json, split_probs=args.split_probs, seed=args.split_seed
+            )
+
+    @property
+    def COMPARTMENTS(self):
+        return [
+            "Nucleus",
+            "Cytoplasm",
+            "Secreted",
+            "Mitochondrion",
+            "Membrane",
+            "Endoplasmic",
+            "Plastid",
+            "Golgi_apparatus",
+            "Lysosome",
+            "Peroxisome",
+        ]
+
+    @property
+    def esm_tokens(self):
+        return [
+            "L",
+            "A",
+            "G",
+            "V",
+            "S",
+            "E",
+            "R",
+            "T",
+            "I",
+            "D",
+            "P",
+            "K",
+            "Q",
+            "N",
+            "F",
+            "Y",
+            "M",
+            "H",
+            "W",
+            "C",
+            "X",
+            "B",
+            "U",
+            "Z",
+            "O",
+            ".",
+            "-",
+        ]
+
+    def target_index(self, target):
+        return self.COMPARTMENTS.index(target)
+
+    def skip_sample(self, sample, split_group) -> bool:
+        """
+        Return True if sample should be skipped and not included in data
+        """
+        if sample is None:
+            return True
+        if self.get_label(sample) is None:
+            # print("Skipped because no label")
+            return True
+        if self.args.drop_multilabel:
+            if self.get_label(sample).sum() > 1:  # skip multi-compartment samples
+                print("Skipped because multi label")
+                return True
+        if split_group in ["train", "dev", "test"]:
+            if sample["split"] != split_group:
+                return True
+        if "sequence" in sample and len(sample["sequence"]) < 10:
+            return True
+        if "sequence" in sample and len(sample["sequence"]) > self.args.max_prot_len:
+            return True
+        if "Sequence" in sample and len(sample["Sequence"]) < 10:
+            return True
+        if "Sequence" in sample and len(sample["Sequence"]) > self.args.max_prot_len:
+            return True
+        if "sequence" in sample and not set(sample["sequence"]).issubset(
+            self.esm_tokens
+        ):
+            return True
+        if "Sequence" in sample and not set(sample["Sequence"]).issubset(
+            self.esm_tokens
+        ):
+            return True
+        return False
+
+    def skip_idr_sample(self, sample, split_group) -> bool:
+        if self.skip_sample(sample, split_group):
+            return True
+
+        if all([len(s) < 10 for s in sample["idrs"]]):  # if all IDRs are small
+            print("Skipped because all IDRs are len 10 or less")
+            return True
+
+        if len(sample["idrs"]) == 0:  # if there are no idrs
+            print("Skipped because no IDRs")
+            return True
+
+    def create_dataset(
+        self, split_group: Literal["train", "dev", "test"]
+    ) -> List[dict]:
+        dataset = []
+        for sample_dict in tqdm(self.metadata_json):
+            if self.skip_sample(sample_dict, split_group):
+                continue
+            sss = "sequence" if "sequence" in sample_dict else "Sequence"
+            eid = "entry" if "entry" in sample_dict else "Entry"
+            item = {
+                "x": sample_dict[sss],
+                "y": self.get_label(sample_dict),
+                "entry_id": sample_dict[eid],
+                # "sample_id": sample_dict["Entry"],
+            }
+            dataset.append(item)
+        return dataset
+
+    def get_label(self, sample):
+        """
+        Get task specific label for a given sample
+        """
+        try:
+            return torch.tensor([sample["labels"][c] for c in self.COMPARTMENTS])
+        except:
+            return None
+
+    def __getitem__(self, index):
+        try:
+            return self.dataset[index]
+
+        except Exception:
+            warnings.warn("Could not load sample")
+
+    @property
+    def SUMMARY_STATEMENT(self) -> None:
+        """
+        Prints summary statement with dataset stats
+        """
+        try:
+            compartment_counts = (
+                torch.stack([d["y"] for d in self.dataset]).sum(0).tolist()
+            )
+            compartment_str = ""
+            for i, (c, count) in enumerate(zip(self.COMPARTMENTS, compartment_counts)):
+                compartment_str += f"{count} {c.upper()}"
+                if i < len(self.COMPARTMENTS) - 1:
+                    compartment_str += " -- "
+            return f"* {len(self.dataset)} Proteins.\n* {compartment_str}"
+        except:
+            return "Could not produce summary statement"
+
+    @staticmethod
+    def set_args(args) -> None:
+        args.num_classes = 10
+
+    @staticmethod
+    def add_args(parser) -> None:
+        """Add class specific args
+
+        Args:
+            parser (argparse.ArgumentParser): argument parser
+        """
+        Protein_Compartments.add_args(parser)
+        parser.add_argument(
+            "--max_prot_len",
+            type=int,
+            default=2000,
+            help="len above which to skip prots",
+        )
+
+        parser.add_argument(
+            "--drop_multilabel",
+            type=bool,
+            default=False,
+            help="whether to drop multilabel samples",
+        )
+
+
+@register_object("protein_compartment_uniprot_combined", "dataset")
+class ProteinCompartmentsUniprotCombined(ProteinCompartmentsGuy):
+    def get_label(self, sample):
+        """
+        Get task specific label for a given sample
+        """
+        try:
+            label = []
+            for c in self.COMPARTMENTS:
+                if isinstance(c, str):
+                    if c in sample["labels"]:
+                        label.append(sample["labels"][c])
+                    else:
+                        label.append(0)
+                else:
+                    l = 0
+                    for c_ in c:
+                        if c_ in sample["labels"]:
+                            if sample["labels"][c_] == 1:
+                                l = 1
+                                break
+                        else:
+                            continue
+                    label.append(l)
+            if sum(label) > 0:
+                return torch.tensor(label)
+            else:
+                return None
+        except:
+            return None
+
+    def target_index(self, target):
+        for i, c in enumerate(self.COMPARTMENTS):
+            if isinstance(c, str):
+                if isinstance(target, str):
+                    if c == target:
+                        return i
+            else:
+                if target in c:
+                    return i
+                elif next(iter(target)) in c:
+                    return i
+        return None
+
+    @property
+    def COMPARTMENTS(self):
+        return [
+            "nuclear_membrane",
+            "rough_endoplasmic_reticulum",
+            "vacuole",
+            "nucleus",
+            "inflammasome",
+            {"endplasmic_reticulum", "endoplasmic_reticulum"},
+            "cytoplasm",
+            "nuclear_gem",
+            {"membrane", "cell_membrane"},
+            "mitochondrion",
+            {"vesicle", "vesicles"},
+            "cell_projection",
+            "lipid_droplet",
+            "sarcoplasmic_reticulum",
+            "endosome",
+            "centromere",
+            "nuclear_body",
+            "nucleoplasm",
+            "golgi_apparatus",
+            {"excretion_vesicles", "excretion_vesicle"},
+            "peroxisome",
+            "lysosome",
+        ]
+
+    @staticmethod
+    def set_args(args) -> None:
+        args.num_classes = 22
+
+
+# USE THIS
+@register_object("protein_condensates_combined", "dataset")
+class ProteinCondensatesCombined(ProteinCompartmentsUniprotCombined):
+    @property
+    def COMPARTMENTS(self):
+        return [
+            {"nuclear_speckles", "nuclear_speckle"},
+            {"pbody", "p-body"},
+            {"pml_body", "pml-bdoy"},
+            "post_synaptic_density",
+            "stress_granule",
+            {"chromosomes", "chromosome"},
+            "nucleolus",
+            "nuclear_pore_complex",
+            "cajal_body",
+            "rna_granule",
+            "cell_junction",
+            "transcriptional",
+        ]
+
+    @staticmethod
+    def set_args(args) -> None:
+        args.num_classes = 12

data/protgps/datasets/reverse_homology.py

@@ -0,0 +1,216 @@
+# dataset utils
+from random import sample
+import warnings
+from typing import Literal, List
+from protgps.datasets.abstract import AbstractDataset
+from protgps.utils.registry import register_object, get_object
+from protgps.utils.classes import set_protgps_type
+from tqdm import tqdm
+import argparse
+import torch
+import os, glob
+import re
+import numpy as np
+from argparse import Namespace
+import copy
+@register_object("reverse_homology", "dataset")
+class ReverseHomology(AbstractDataset):
+    """A pytorch Dataset for the classifying proteins into compartment."""
+    def load_homology_dataset(self, args: argparse.ArgumentParser) -> None:
+        """Loads fasta files from dataset folder
+        Args:
+            args (argparse.ArgumentParser)
+        Raises:
+            Exception: Unable to load
+        """
+        data_folders = args.homology_dataset_folder.split(",")
+        fasta_paths = []
+        for folder_path in data_folders:
+            fasta_paths.extend(glob.glob(os.path.join(folder_path, '*.fasta')))
+        print("Loading fasta files...")
+        for fasta in tqdm(fasta_paths):
+            idrs = []
+            f=open(fasta, 'r')
+            lines=f.readlines()
+            for line in lines:
+                outh=re.search('>', line)
+                if outh:
+                    pass
+                else:
+                    s = line.replace('-','').strip()
+                    if len(s) <= self.args.max_idr_len: # skip long sequences
+                        idrs.append(s)
+            if len(idrs) >= self.args.pos_samples+1:
+                self.homology_sets.append(np.array(idrs))
+        
+    def init_class(self, args: argparse.ArgumentParser, split_group: str) -> None:
+        """Perform Class-Specific init methods
+           Default is to load JSON dataset
+
+        Args:
+            args (argparse.ArgumentParser)
+            split_group (str)
+        """
+        self.homology_sets = []
+        if self.args.homology_dataset_folder and self.args.use_homology_dataset:
+            self.load_homology_dataset(args)
+        if self.args.compartment_dataset_file and self.args.use_compartment_dataset:
+            self.load_compartment_dataset(copy.deepcopy(args))
+
+    def load_compartment_dataset(self, args: argparse.ArgumentParser) -> None:
+        """Loads dataset from json file
+        Args:
+            args (argparse.ArgumentParser)
+        """
+        if self.args.compartment_dataset_name:
+            args.dataset_file_path = self.args.compartment_dataset_file
+            args.drop_multilabel = False
+            args.max_prot_len = np.inf
+            dataset = get_object(self.args.compartment_dataset_name, "dataset")(
+                args, "train"
+            )
+            comp_dict = {}
+            for sample_dict in tqdm(dataset.metadata_json):
+                idrs = "".join(sample_dict["idrs"])
+                if len(idrs) <= self.args.max_idr_len:
+                    label = dataset.get_label(sample_dict)
+                    for l in torch.argwhere(label == 1).T[0]:
+                        l = l.item()
+                        if l in comp_dict:
+                            comp_dict[l].append(idrs)
+                        else:
+                            comp_dict[l] = [idrs]
+            
+            for label in comp_dict:
+                if len(comp_dict[label]) >= self.args.pos_samples+1:
+                    self.homology_sets.append(np.array(comp_dict[label]))
+        else:
+            raise Exception("No compartment dataset name provided")
+
+
+    def create_dataset(
+        self, split_group: Literal["train", "dev", "test"]
+    ) -> List[dict]:
+        dataset = []
+        print(f"Creating '{split_group}' dataset...")
+        if split_group == "train":
+            hom_mult = self.args.homology_multiple*self.args.split_probs[0]
+            rng = np.random.default_rng(self.args.dataset_seed)
+        elif split_group == "dev":
+            hom_mult = self.args.homology_multiple*self.args.split_probs[1]
+            rng = np.random.default_rng(self.args.dataset_seed+1)
+        elif split_group == "test":
+            hom_mult = self.args.homology_multiple*self.args.split_probs[2]
+            rng = np.random.default_rng(self.args.dataset_seed+2)
+
+        for _ in tqdm(range(int(hom_mult*len(self.homology_sets)))):
+            sample, rng = self.generate_sample(rng)
+            dataset.append(sample)
+        return dataset
+
+    def generate_sample(self, rng) -> dict:
+        """Generates sample for contrastive learning of homology sets
+        Args:
+            rng: numpy random generator
+        Returns:
+            list: list of strings
+        """
+        if len(self.homology_sets) < self.args.neg_samples+1:
+            self.args.neg_samples = len(self.homology_sets)-1
+        neg_idx = rng.choice(len(self.homology_sets), size=self.args.neg_samples+1, replace=False)
+        pos_idx, neg_idx = neg_idx[0], neg_idx[1:]
+        pos_samples = rng.choice(self.homology_sets[pos_idx], size=self.args.pos_samples+1, replace=False)
+        anchor, pos_samples = pos_samples[0], pos_samples[1:]
+        neg_samples = np.array([rng.choice(self.homology_sets[i],size=self.args.neg_multiple) for i in neg_idx]).flatten()
+        return {"x":[anchor, *pos_samples, *neg_samples]}, rng
+    
+    def __getitem__(self, index):
+        # rng = np.random.default_rng(self.args.dataset_seed)
+        try:
+            return self.dataset[index]
+        except Exception:
+            warnings.warn("Could not load sample")
+
+    @property
+    def SUMMARY_STATEMENT(self) -> None:
+        """
+        Prints summary statement with dataset stats
+        """
+        try:
+            return f"Reverse Homology Dataset with {len(self.dataset)} samples\n"\
+            + f"Using Homology sets: {len(self.homology_sets)}\n"\
+            + f"Using {self.args.pos_samples} positive samples and {self.args.neg_samples*self.args.neg_multiple} negative samples\n"
+        except:
+            return "Could not produce summary statement"
+
+    @staticmethod
+    def set_args(args) -> None:
+        args.num_classes = 2
+
+    @staticmethod
+    def add_args(parser) -> None:
+        """Add class specific args
+
+        Args:
+            parser (argparse.ArgumentParser): argument parser
+        """
+        super(ReverseHomology, ReverseHomology).add_args(parser)
+        parser.add_argument(
+            "--homology_dataset_folder",
+            type=str,
+            help="folders containing fasta files seperated by comma",
+        )
+        parser.add_argument(
+            "--dataset_seed",
+            type=int,
+            help="seed for dataset generation",
+        )
+        parser.add_argument(
+            "--homology_multiple",
+            type=float,
+            default=1,
+            help="the expected number of times to use each homology set as a positive example",
+        )
+        parser.add_argument(
+            "--pos_samples",
+            type=int,
+            help="number of positive samples to use from the anchor homology set",
+        )
+        parser.add_argument(
+            "--neg_samples",
+            type=int,
+            help="number of homology sets to draw negative samples from",
+        )
+        parser.add_argument(
+            "--max_idr_len",
+            type=int,
+            help="max total length of idrs in a protein",
+        )
+        parser.add_argument(
+            "--compartment_dataset_file",
+            type=str,
+            help="json file containing compartment dataset",
+        )
+        parser.add_argument(
+            "--compartment_dataset_name",
+            type=str,
+            help="protgps name of compartment dataset object",
+        )
+        parser.add_argument(
+            "--use_compartment_dataset",
+            action="store_true",
+            default=False,
+            help="use compartment dataset to generate homology sets",
+        )
+        parser.add_argument(
+            "--use_homology_dataset",
+            action="store_true",
+            default=False,
+            help="use homology dataset to generate homology sets",
+        )
+        parser.add_argument(
+            "--neg_multiple",
+            type=int,
+            default=1,
+            help="number of negative samples to draw from each negative homology set",
+        )

data/protgps/learning/losses/basic.py

@@ -0,0 +1,156 @@
+from protgps.utils.registry import register_object
+import torch
+import torch.nn.functional as F
+import torch.nn as nn
+from collections import OrderedDict
+import pdb
+from protgps.utils.classes import ProtGPS
+
+
+@register_object("cross_entropy", "loss")
+class CrossEntropyLoss(ProtGPS):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def __call__(self, model_output, batch, model, args):
+        logging_dict, predictions = OrderedDict(), OrderedDict()
+        logit = model_output["logit"]
+        loss = F.cross_entropy(logit, batch["y"].long()) * args.ce_loss_lambda
+        logging_dict["cross_entropy_loss"] = loss.detach()
+        predictions["probs"] = F.softmax(logit, dim=-1).detach()
+        predictions["golds"] = batch["y"]
+        predictions["preds"] = predictions["probs"].argmax(axis=-1).reshape(-1)
+        return loss, logging_dict, predictions
+
+    @staticmethod
+    def add_args(parser) -> None:
+        """Add class specific args
+
+        Args:
+            parser (argparse.ArgumentParser): argument parser
+        """
+        parser.add_argument(
+            "--ce_loss_lambda",
+            type=float,
+            default=1.0,
+            help="Lambda to weigh the cross-entropy loss.",
+        )
+
+
+@register_object("binary_cross_entropy", "loss")
+class BinaryCrossEntropyLoss(ProtGPS):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def __call__(self, model_output, batch, model, args):
+        logging_dict, predictions = OrderedDict(), OrderedDict()
+        logit = model_output["logit"]
+        loss = (
+            F.binary_cross_entropy_with_logits(logit, batch["y"].float())
+            * args.bce_loss_lambda
+        )
+        logging_dict["binary_cross_entropy_loss"] = loss.detach()
+        predictions["probs"] = torch.sigmoid(logit).detach()
+        predictions["golds"] = batch["y"]
+        predictions["preds"] = (predictions["probs"] > 0.5).int()
+        return loss, logging_dict, predictions
+
+    @staticmethod
+    def add_args(parser) -> None:
+        """Add class specific args
+
+        Args:
+            parser (argparse.ArgumentParser): argument parser
+        """
+        parser.add_argument(
+            "--bce_loss_lambda",
+            type=float,
+            default=1.0,
+            help="Lambda to weigh the binary cross-entropy loss.",
+        )
+
+
+@register_object("survival", "loss")
+class SurvivalLoss(ProtGPS):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def __call__(self, model_output, batch, model, args):
+        logging_dict, predictions = OrderedDict(), OrderedDict()
+        logit = model_output["logit"]
+        y_seq, y_mask = batch["y_seq"], batch["y_mask"]
+        loss = F.binary_cross_entropy_with_logits(
+            logit, y_seq.float(), weight=y_mask.float(), reduction="sum"
+        ) / torch.sum(y_mask.float())
+        logging_dict["survival_loss"] = loss.detach()
+        predictions["probs"] = torch.sigmoid(logit).detach()
+        predictions["golds"] = batch["y"]
+        predictions["censors"] = batch["time_at_event"]
+        return loss, logging_dict, predictions
+
+
+@register_object("ordinal_cross_entropy", "loss")
+class RankConsistentLoss(ProtGPS):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def __call__(self, model_output, batch, model, args):
+        """
+        Computes cross-entropy loss
+
+        If batch contains they key 'has_y', the cross entropy loss will be computed for samples where batch['has_y'] = 1
+        Expects model_output to contain 'logit'
+
+        Returns:
+            loss: cross entropy loss
+            l_dict (dict): dictionary containing cross_entropy_loss detached from computation graph
+            p_dict (dict): dictionary of model predictions and ground truth labels (preds, probs, golds)
+        """
+        loss = 0
+        l_dict, p_dict = OrderedDict(), OrderedDict()
+        logit = model_output["logit"]
+        yseq = batch["yseq"]
+        ymask = batch["ymask"]
+
+        loss = F.binary_cross_entropy_with_logits(
+            logit, yseq.float(), weight=ymask.float(), reduction="sum"
+        ) / torch.sum(ymask.float())
+
+        probs = F.logsigmoid(logit)  # log_sum to add probs
+        probs = probs.unsqueeze(1).repeat(1, len(args.rank_thresholds), 1)
+        probs = torch.tril(probs).sum(2)
+        probs = torch.exp(probs)
+
+        p_dict["logits"] = logit.detach()
+        p_dict["probs"] = probs.detach()
+        preds = probs > 0.5  # class = last prob > 0.5
+        preds = preds.sum(-1)
+        p_dict["preds"] = preds
+        p_dict["golds"] = batch["y"]
+
+        return loss, l_dict, p_dict
+
+@register_object("contrastive", "loss")
+class ContrastiveLoss(ProtGPS):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def __call__(self, model_output, batch, model, args):
+        logging_dict, predictions = OrderedDict(), OrderedDict()
+        logit = model_output["hidden"]
+        sample_size = 1 + args.pos_samples + args.neg_samples
+        idx = 0 #NOTE: this is for batch size 1
+        anchor = logit[idx]
+        pos_samples = logit[idx+1:idx+args.pos_samples+1].mean(0)
+        neg_samples = logit[idx+args.pos_samples+1:idx+sample_size]
+        assert neg_samples.shape[0] == args.neg_samples
+        pos_score = torch.exp(torch.dot(pos_samples, anchor))
+        neg_score = torch.exp(torch.matmul(neg_samples, anchor)).sum()
+        prob = pos_score/(pos_score + neg_score)
+        loss = -torch.log(prob)
+        logging_dict["contrastive_loss"] = loss.detach()
+        probs = torch.Tensor([prob, 1-prob])
+        predictions["probs"] = probs.detach()
+        predictions["preds"] = (probs > 0.5).int()
+        predictions["golds"] = torch.Tensor([1,0]).int()
+        return loss, logging_dict, predictions

data/protgps/learning/metrics/basic.py

@@ -0,0 +1,359 @@
+from typing import Dict
+from protgps.utils.registry import register_object
+from collections import OrderedDict
+from protgps.utils.classes import ProtGPS
+import numpy as np
+import pdb
+from torchmetrics.functional import (
+    accuracy,
+    auroc,
+    precision,
+    recall,
+    confusion_matrix,
+    f1_score,
+    precision_recall_curve,
+    average_precision,
+)
+from torchmetrics.utilities.compute import auc
+import torch
+import copy
+
+EPSILON = 1e-6
+BINARY_CLASSIF_THRESHOLD = 0.5
+
+precision_recall = lambda probs, golds, **kwargs: (
+    precision(probs, golds, **kwargs),
+    recall(probs, golds, **kwargs),
+)
+
+
+@register_object("classification", "metric")
+class BaseClassification(ProtGPS):
+    def __init__(self, args) -> None:
+        super().__init__()
+
+    @property
+    def metric_keys(self):
+        return ["probs", "preds", "golds"]
+
+    def __call__(self, predictions_dict, args) -> Dict:
+        """
+        Computes standard classification metrics
+
+        Args:
+            predictions_dict: dictionary obtained from computing loss and model outputs
+                * should contain the keys ['probs', 'preds', 'golds']
+            args: argparser Namespace
+
+        Returns:
+            stats_dict (dict): contains (where applicable) values for accuracy, confusion matrix, precision, recall, f1, precision-recall auc, roc auc
+
+        Note:
+            In multiclass setting (>2), accuracy, and micro-f1, micro-recall, micro-precision are equivalent
+            Macro: calculates metric per class then averages
+        """
+        stats_dict = OrderedDict()
+
+        probs = predictions_dict["probs"]  # B, C (float)
+        preds = predictions_dict["preds"]  # B
+        golds = predictions_dict["golds"]  # B
+        stats_dict["accuracy"] = accuracy(golds, preds)
+        stats_dict["confusion_matrix"] = confusion_matrix(
+            preds, golds, args.num_classes
+        )
+        if args.num_classes == 2:
+            if len(probs.shape) == 1:
+                stats_dict["precision"], stats_dict["recall"] = precision_recall(
+                    probs, golds
+                )
+                stats_dict["f1"] = f1_score(probs, golds)
+                pr, rc, _ = precision_recall_curve(probs, golds)
+                stats_dict["pr_auc"] = auc(rc, pr)
+                try:
+                    stats_dict["roc_auc"] = auroc(probs, golds, pos_label=1)
+                except:
+                    pass
+            else:
+                stats_dict["precision"], stats_dict["recall"] = precision_recall(
+                    probs, golds, multiclass=False, num_classes=2
+                )
+                stats_dict["f1"] = f1_score(
+                    probs, golds, multiclass=False, num_classes=2
+                )
+                pr, rc, _ = precision_recall_curve(probs, golds, num_classes=2)
+                stats_dict["pr_auc"] = auc(rc[-1], pr[-1])
+                try:
+                    stats_dict["roc_auc"] = auroc(probs, golds, num_classes=2)
+                except:
+                    pass
+        else:
+            stats_dict["precision"], stats_dict["recall"] = precision_recall(
+                probs, golds, num_classes=args.num_classes, average="macro"
+            )
+            stats_dict["f1"] = f1_score(
+                probs, golds, num_classes=args.num_classes, average="macro"
+            )
+            stats_dict["micro_f1"] = f1_score(
+                probs, golds, num_classes=args.num_classes, average="micro"
+            )
+            if len(torch.unique(golds)) == args.num_classes:
+                pr, rc, _ = precision_recall_curve(
+                    probs, golds, num_classes=args.num_classes
+                )
+                stats_dict["pr_auc"] = torch.mean(
+                    torch.stack([auc(rc[i], pr[i]) for i in range(args.num_classes)])
+                )
+                stats_dict["roc_auc"] = auroc(
+                    probs, golds, num_classes=args.num_classes, average="macro"
+                )
+
+            if args.store_classwise_metrics:
+                classwise_metrics = {}
+                (
+                    classwise_metrics["precisions"],
+                    classwise_metrics["recalls"],
+                ) = precision_recall(
+                    probs, golds, num_classes=args.num_classes, average="none"
+                )
+                classwise_metrics["f1s"] = f1_score(
+                    probs, golds, num_classes=args.num_classes, average="none"
+                )
+                pr, rc, _ = precision_recall_curve(
+                    probs, golds, num_classes=args.num_classes
+                )
+                classwise_metrics["pr_aucs"] = [
+                    auc(rc[i], pr[i]) for i in range(args.num_classes)
+                ]
+                classwise_metrics["accs"] = accuracy(
+                    golds, preds, num_classes=args.num_classes, average="none"
+                )
+                try:
+                    classwise_metrics["rocaucs"] = auroc(
+                        probs, golds, num_classes=args.num_classes, average="none"
+                    )
+                except:
+                    pass
+
+                for metricname in [
+                    "precisions",
+                    "recalls",
+                    "f1s",
+                    "rocaucs",
+                    "pr_aucs",
+                    "accs",
+                ]:
+                    if metricname in classwise_metrics:
+                        stats_dict.update(
+                            {
+                                "class{}_{}".format(i + 1, metricname): v
+                                for i, v in enumerate(classwise_metrics[metricname])
+                            }
+                        )
+        return stats_dict
+
+    @staticmethod
+    def add_args(parser) -> None:
+        """Add class specific args
+
+        Args:
+            parser (argparse.ArgumentParser): argument parser
+        """
+        parser.add_argument(
+            "--store_classwise_metrics",
+            action="store_true",
+            default=False,
+            help="Whether to log metrics per class or just log average across classes",
+        )
+
+
+@register_object("multilabel_classification", "metric")
+class MultiLabelClassification(ProtGPS):
+    def __init__(self, args) -> None:
+        super().__init__()
+
+    @property
+    def metric_keys(self):
+        return ["probs", "preds", "golds"]
+
+    def __call__(self, predictions_dict, args) -> Dict:
+        """
+        Computes classification metrics for multi-label predictions (i.e., predicting multiple categories independently -- sigmoid outputs)
+
+        Args:
+            predictions_dict: dictionary obtained from computing loss and model outputs
+                * should contain the keys ['probs', 'preds', 'golds']
+            args: argparser Namespace
+
+        Returns:
+            stats_dict (dict): contains (where applicable) values for accuracy, confusion matrix, precision, recall, f1, precision-recall auc, roc auc
+
+        """
+        stats_dict = OrderedDict()
+
+        probs = predictions_dict["probs"]  # B, C
+        preds = predictions_dict["preds"]  # B, C
+        golds = predictions_dict["golds"].int()  # B, C
+        stats_dict["accuracy"] = accuracy(
+            golds, preds, task="multilabel", num_labels=args.num_classes
+        )
+
+        stats_dict["precision"], stats_dict["recall"] = precision_recall(
+            probs,
+            golds,
+            average="macro",
+            task="multilabel",
+            num_labels=args.num_classes,
+        )
+        stats_dict["f1"] = f1_score(
+            probs,
+            golds,
+            num_labels=args.num_classes,
+            average="macro",
+            task="multilabel",
+        )
+        stats_dict["micro_f1"] = f1_score(
+            probs,
+            golds,
+            num_labels=args.num_classes,
+            average="micro",
+            task="multilabel",
+        )
+        stats_dict["ap_score"] = average_precision(
+            probs,
+            golds,
+            num_labels=args.num_classes,
+            average="macro",
+            task="multilabel",
+        )
+
+        stats_dict["roc_auc"] = auroc(
+            probs,
+            golds,
+            num_labels=args.num_classes,
+            average="macro",
+            task="multilabel",
+        )
+
+        return stats_dict
+
+
+@register_object("ordinal_classification", "metric")
+class Ordinal_Classification(BaseClassification):
+    def __call__(self, predictions_dict, args) -> Dict:
+        """
+        Computes classification for metrics when predicting multiple independent classes
+
+        Args:
+            predictions_dict: dictionary obtained from computing loss and model outputs
+            args: argparser Namespace
+
+        Returns:
+            stats_dict (dict): contains (where applicable) values for accuracy, confusion matrix, precision, recall, f1, precision-recall auc, roc auc, prefixed by col index
+        """
+        stats_dict = OrderedDict()
+
+        probs = predictions_dict["probs"]  # B, C (float)
+        preds = predictions_dict["preds"]  # B
+        golds = predictions_dict["golds"]  # B
+        stats_dict["accuracy"] = accuracy(golds, preds)
+        stats_dict["confusion_matrix"] = confusion_matrix(
+            preds, golds, args.num_classes + 1
+        )
+
+        for classindex in range(golds.shape[-1]):
+            (
+                stats_dict["class{}_precision".format(classindex)],
+                stats_dict["class{}_recall".format(classindex)],
+            ) = precision_recall(probs, golds)
+            stats_dict["class{}_f1".format(classindex)] = f1_score(probs, golds)
+            pr, rc, _ = precision_recall_curve(probs, golds)
+            stats_dict["class{}_pr_auc".format(classindex)] = auc(rc, pr)
+            try:
+                stats_dict["class{}_roc_auc".format(classindex)] = auroc(
+                    probs, golds, pos_label=1
+                )
+            except:
+                pass
+
+        return stats_dict
+
+
+@register_object("survival_classification", "metric")
+class Survival_Classification(BaseClassification):
+    def __call__(self, predictions_dict, args):
+        stats_dict = OrderedDict()
+
+        golds = predictions_dict["golds"]
+        probs = predictions_dict["probs"]
+        preds = probs[:, -1].view(-1) > 0.5
+        probs = probs.reshape((-1, probs.shape[-1]))[:, -1]
+
+        stats_dict["accuracy"] = accuracy(golds, preds)
+
+        if (args.num_classes == 2) and not (
+            np.unique(golds)[-1] > 1 or np.unique(preds)[-1] > 1
+        ):
+            stats_dict["precision"], stats_dict["recall"] = precision_recall(
+                probs, golds
+            )
+            stats_dict["f1"] = f1_score(probs, golds)
+            num_pos = golds.sum()
+            if num_pos > 0 and num_pos < len(golds):
+                stats_dict["auc"] = auroc(probs, golds, pos_label=1)
+                stats_dict["ap_score"] = average_precision(probs, golds)
+                precision, recall, _ = precision_recall_curve(probs, golds)
+                stats_dict["prauc"] = auc(recall, precision)
+        return stats_dict
+
+
+@register_object("discrim_classification", "metric")
+class Discriminator_Classification(BaseClassification):
+    def __init__(self, args) -> None:
+        super().__init__(args)
+
+    @property
+    def metric_keys(self):
+        return ["discrim_probs", "discrim_golds"]
+
+    def __call__(self, predictions_dict, args):
+        stats_dict = OrderedDict()
+
+        golds = predictions_dict["discrim_golds"]
+        probs = predictions_dict["discrim_probs"]
+        preds = predictions_dict["discrim_probs"].argmax(axis=-1).reshape(-1)
+
+        nargs = copy.deepcopy(args)
+        nargs.num_classes = probs.shape[-1]
+        stats_dict = super().__call__(
+            {"golds": golds, "probs": probs, "preds": preds}, nargs
+        )
+        stats_dict = {"discrim_{}".format(k): v for k, v in stats_dict.items()}
+
+        return stats_dict
+
+
+@register_object("multi_discrim_classification", "metric")
+class MultiDiscriminator_Classification(BaseClassification):
+    def __init__(self, args) -> None:
+        super().__init__(args)
+
+    @property
+    def metric_keys(self):
+        return ["device_probs", "device_golds", "thickness_probs", "thickness_golds"]
+
+    def __call__(self, predictions_dict, args):
+        stats_dict = OrderedDict()
+
+        for key in ["device", "thickness"]:
+            golds = predictions_dict["{}_golds".format(key)]
+            probs = predictions_dict["{}_probs".format(key)]
+            preds = predictions_dict["{}_probs".format(key)].argmax(axis=-1).reshape(-1)
+
+            nargs = copy.deepcopy(args)
+            nargs.num_classes = probs.shape[-1]
+            stats_dict = super().__call__(
+                {"golds": golds, "probs": probs, "preds": preds}, nargs
+            )
+            stats_dict = {"{}_{}".format(key, k): v for k, v in stats_dict.items()}
+
+        return stats_dict

data/protgps/learning/optimizers/basic.py

@@ -0,0 +1,29 @@
+import torch
+from torch import optim
+from protgps.utils.registry import register_object
+from protgps.utils.classes import ProtGPS
+
+
+@register_object("sgd", "optimizer")
+class SGD(optim.SGD, ProtGPS):
+    """
+    https://pytorch.org/docs/stable/generated/torch.optim.SGD.html#torch.optim.SGD
+    """
+
+    def __init__(self, params, args):
+        super().__init__(
+            params=params,
+            lr=args.lr,
+            momentum=args.momentum,
+            weight_decay=args.weight_decay,
+        )
+
+
+@register_object("adam", "optimizer")
+class Adam(optim.Adam, ProtGPS):
+    """
+    https://pytorch.org/docs/stable/generated/torch.optim.Adam.html#torch.optim.Adam
+    """
+
+    def __init__(self, params, args):
+        super().__init__(params=params, lr=args.lr, weight_decay=args.weight_decay)

data/protgps/learning/schedulers/basic.py

@@ -0,0 +1,53 @@
+import torch
+from torch import optim
+from protgps.utils.registry import register_object
+from protgps.utils.classes import ProtGPS
+
+
+@register_object("reduce_on_plateau", "scheduler")
+class ReduceLROnPlateau(optim.lr_scheduler.ReduceLROnPlateau, ProtGPS):
+    """
+    https://pytorch.org/docs/stable/generated/torch.optim.lr_scheduler.ReduceLROnPlateau.html#torch.optim.lr_scheduler.ReduceLROnPlateau
+    """
+
+    def __init__(self, optimizer, args):
+        super().__init__(
+            optimizer,
+            patience=args.patience,
+            factor=args.lr_decay,
+            mode="min" if "loss" in args.monitor else "max",
+        )
+
+
+@register_object("exponential_decay", "scheduler")
+class ExponentialLR(optim.lr_scheduler.ExponentialLR, ProtGPS):
+    """
+    https://pytorch.org/docs/stable/generated/torch.optim.lr_scheduler.ExponentialLR.html#torch.optim.lr_scheduler.ExponentialLR
+    """
+
+    def __init__(self, optimizer, args):
+        super().__init__(optimizer, gamma=args.lr_decay)
+
+
+@register_object("cosine_annealing", "scheduler")
+class CosineAnnealingLR(optim.lr_scheduler.CosineAnnealingLR, ProtGPS):
+    """
+    https://pytorch.org/docs/stable/generated/torch.optim.lr_scheduler.CosineAnnealingLR.html
+    """
+
+    def __init__(self, optimizer, args):
+        super().__init__(optimizer, args.cosine_annealing_period)
+
+
+@register_object("cosine_annealing_restarts", "scheduler")
+class CosineAnnealingWarmRestarts(optim.lr_scheduler.CosineAnnealingWarmRestarts, ProtGPS):
+    """
+    https://pytorch.org/docs/stable/generated/torch.optim.lr_scheduler.CosineAnnealingWarmRestarts.html#torch.optim.lr_scheduler.CosineAnnealingWarmRestarts
+    """
+
+    def __init__(self, optimizer, args):
+        super().__init__(
+            optimizer,
+            T_0=args.cosine_annealing_period,
+            T_mult=args.cosine_annealing_period_scaling,
+        )

data/protgps/learning/searchers/basic.py

@@ -0,0 +1,16 @@
+import torch
+from torch import optim
+from protgps.utils.registry import register_object
+from protgps.utils.classes import ProtGPS
+from ray.tune.suggest import BasicVariantGenerator
+
+
+@register_object("basic", "searcher")
+class BasicSearch(BasicVariantGenerator, ProtGPS):
+    """Description
+
+    See: https://docs.ray.io/en/releases-0.8.4/tune-searchalg.html#variant-generation-grid-search-random-search
+    """
+
+    def __init__(self, args):
+        super().__init__()

data/protgps/learning/utils.py

@@ -0,0 +1,5 @@
+def off_diagonal(x):
+    n, m = x.shape
+    assert n == m
+    return x.flatten()[:-1].view(n - 1, n + 1)[:, 1:].flatten()
+    

data/protgps/lightning/base.py

@@ -0,0 +1,455 @@
+import torch
+import pytorch_lightning as pl
+import torch.nn.functional as F
+import numpy as np
+from collections import OrderedDict
+import pickle
+import os
+from protgps.utils.registry import get_object, register_object
+from protgps.utils.classes import ProtGPS, set_protgps_type
+
+
+@register_object("base", "lightning")
+class Base(pl.LightningModule, ProtGPS):
+    """
+    PyTorch Lightning module used as base for running training and test loops
+
+    Args:
+        args: argparser Namespace
+    """
+
+    def __init__(self, args):
+        super(Base, self).__init__()
+        self.save_hyperparameters()
+        self.args = args
+        self.model = get_object(args.model_name, "model")(args)
+
+    def setup(self, stage):
+        self.loss_fns = {
+            "train": [get_object(l, "loss")() for l in self.args.loss_names]
+        }
+        self.loss_fns["val"] = self.loss_fns["train"]
+        self.loss_fns["test"] = (
+            self.loss_fns["train"]
+            if self.args.loss_names_for_eval is None
+            else [get_object(l, "loss")() for l in self.args.loss_names_for_eval]
+        )
+        self.metrics = [
+            get_object(m, "metric")(self.args) for m in self.args.metric_names
+        ]
+        self.metric_keys = list(
+            set([key for metric in self.metrics for key in metric.metric_keys])
+        )
+
+    @property
+    def LOG_KEYS(self):
+        return [
+            "loss",
+            "accuracy",
+            "mean",
+            "std",
+            "precision",
+            "recall",
+            "f1",
+            "auc",
+            "similarity",
+            "tau",
+            "mse",
+            "mae",
+            "r2",
+            "c_index",
+            "hit",
+            "pearson",
+            "spearman",
+        ]
+
+    @property
+    def UNLOG_KEYS(self):
+        default = ["activ", "hidden"]
+        keys_to_unlog = []
+        for k in default:
+            if k not in self.metric_keys:
+                keys_to_unlog.append(k)
+        return keys_to_unlog
+
+    def step(self, batch, batch_idx, optimizer_idx):
+        """
+        Defines a single training or validation step:
+            Computes losses given batch and model outputs
+
+        Returns:
+            logged_output: dict with losses and predictions
+
+        Args:
+            batch: dict obtained from DataLoader. batch must contain they keys ['x', 'sample_id']
+        """
+        logged_output = OrderedDict()
+        model_output = self.model(batch)
+        loss, logging_dict, predictions_dict = self.compute_loss(model_output, batch)
+        predictions_dict = self.store_in_predictions(predictions_dict, batch)
+        predictions_dict = self.store_in_predictions(predictions_dict, model_output)
+
+        logged_output["loss"] = loss
+        logged_output.update(logging_dict)
+        logged_output["preds_dict"] = predictions_dict
+
+        if (
+            (self.args.log_gen_image)
+            and (self.trainer.is_global_zero)
+            and (batch_idx == 0)
+            and (self.current_epoch % 100 == 0)
+        ):
+            self.log_image(model_output, batch)
+
+        return logged_output
+
+    def forward(self, batch, batch_idx=0):
+        """
+        Forward defines the prediction/inference actions
+            Similar to self.step() but also allows for saving predictions and hiddens
+            Computes losses given batch and model outputs
+
+        Returns:
+            logged_output: dict with losses and predictions
+
+        Args:
+            batch: dict obtained from DataLoader. batch must contain they keys ['x', 'sample_id']
+        """
+        logged_output = OrderedDict()
+        model_output = self.model(batch)
+        if not self.args.predict:
+            loss, logging_dict, predictions_dict = self.compute_loss(
+                model_output, batch
+            )
+            predictions_dict = self.store_in_predictions(predictions_dict, batch)
+        predictions_dict = self.store_in_predictions(predictions_dict, model_output)
+        logged_output["loss"] = loss
+        logged_output.update(logging_dict)
+        logged_output["preds_dict"] = predictions_dict
+        if self.args.save_hiddens:
+            logged_output["preds_dict"].update(model_output)
+
+        if (self.args.log_gen_image) and (batch_idx == 0):
+            self.log_image(model_output, batch)
+        return logged_output
+
+    def training_step(self, batch, batch_idx, optimizer_idx=None):
+        """
+        Single training step
+        """
+        self.phase = "train"
+        output = self.step(batch, batch_idx, optimizer_idx)
+        return output
+
+    def validation_step(self, batch, batch_idx, optimizer_idx=None):
+        """
+        Single validation step
+        """
+        self.phase = "val"
+        output = self.step(batch, batch_idx, optimizer_idx)
+        return output
+
+    def test_step(self, batch, batch_idx):
+        """
+        Single testing step
+
+        * save_predictions will save the dictionary output['preds_dict'], which typically includes sample_ids, probs, predictions, etc.
+        * save_hiddens: will save the value of output['preds_dict']['hidden']
+        """
+        self.phase = "test"
+        output = self.forward(batch, batch_idx)
+        if self.args.save_predictions:
+            self.save_predictions(output["preds_dict"])
+        elif self.args.save_hiddens:
+            self.save_hiddens(output["preds_dict"])
+        output = {k: v for k, v in output.items() if k not in self.UNLOG_KEYS}
+        output["preds_dict"] = {
+            k: v for k, v in output["preds_dict"].items() if k not in self.UNLOG_KEYS
+        }
+        return output
+
+    def training_epoch_end(self, outputs):
+        """
+        End of single training epoch
+            - Aggregates predictions and losses from all steps
+            - Computes the metric (auc, accuracy, etc.)
+        """
+        if len(outputs) == 0:
+            return
+        outputs = gather_step_outputs(outputs)
+        outputs["loss"] = outputs["loss"].mean()
+        outputs.update(self.compute_metric(outputs["preds_dict"]))
+        self.log_outputs(outputs, "train")
+        return
+
+    def validation_epoch_end(self, outputs):
+        """
+        End of single validation epoch
+            - Aggregates predictions and losses from all steps
+            - Computes the metric (auc, accuracy, etc.)
+        """
+        if len(outputs) == 0:
+            return
+        outputs = gather_step_outputs(outputs)
+        outputs["loss"] = outputs["loss"].mean()
+        outputs.update(self.compute_metric(outputs["preds_dict"]))
+        self.log_outputs(outputs, "val")
+        return
+
+    def test_epoch_end(self, outputs):
+        """
+        End of testing
+            - Aggregates predictions and losses from all batches
+            - Computes the metric if defined in args
+        """
+        if len(outputs) == 0:
+            return
+        outputs = gather_step_outputs(outputs)
+        if isinstance(outputs.get("loss", 0), torch.Tensor):
+            outputs["loss"] = outputs["loss"].mean()
+        if not self.args.predict:
+            outputs.update(self.compute_metric(outputs["preds_dict"]))
+        self.log_outputs(outputs, "test")
+        return
+
+    def configure_optimizers(self):
+        """
+        Obtain optimizers and hyperparameter schedulers for model
+
+        """
+        optimizer = get_object(self.args.optimizer_name, "optimizer")(
+            self.parameters(), self.args
+        )
+        schedule = get_object(self.args.scheduler_name, "scheduler")(
+            optimizer, self.args
+        )
+
+        scheduler = {
+            "scheduler": schedule,
+            "monitor": self.args.monitor,
+            "interval": "epoch",
+            "frequency": 1,
+        }
+        return [optimizer], [scheduler]
+
+    def compute_loss(self, model_output, batch):
+        """
+        Compute model loss:
+            Iterates through loss functions defined in args and computes losses and predictions
+            Adds losses and stores predictions for batch in dictionary
+
+        Returns:
+            total_loss (torch.Tensor): aggregate loss value that is propagated backwards for gradient computation
+            logging_dict: dict of losses (and other metrics)
+            predictions: dict of predictions (preds, probs, etc.)
+        """
+        total_loss = 0
+        logging_dict, predictions = OrderedDict(), OrderedDict()
+        for loss_fn in self.loss_fns[self.phase]:
+            loss, l_dict, p_dict = loss_fn(model_output, batch, self, self.args)
+            total_loss += loss
+            logging_dict.update(l_dict)
+            predictions.update(p_dict)
+        return total_loss, logging_dict, predictions
+
+    def compute_metric(self, predictions):
+        logging_dict = OrderedDict()
+        for metric_fn in self.metrics:
+            l_dict = metric_fn(predictions, self.args)
+            logging_dict.update(l_dict)
+        return logging_dict
+
+    def store_in_predictions(self, preds, storage_dict):
+        for m in get_object(self.args.dataset_name, "dataset").DATASET_ITEM_KEYS:
+            if m in storage_dict:
+                preds[m] = storage_dict[m]
+
+        for m in self.metric_keys:
+            if m in storage_dict:
+                if torch.is_tensor(storage_dict[m]) and storage_dict[m].requires_grad:
+                    preds[m] = storage_dict[m].detach()
+                else:
+                    preds[m] = storage_dict[m]
+        return preds
+
+    def log_outputs(self, outputs, key):
+        """
+        Compute performance metrics after epoch ends:
+            Iterates through metric functions defined in args and computes metrics
+            Logs the metric values into logger (Comet, Tensorboard, etc.)
+        """
+        logging_dict = {}
+        for k, v in outputs.items():
+            if isinstance(v, torch.Tensor) and any([i in k for i in self.LOG_KEYS]):
+                logging_dict["{}_{}".format(key, k)] = v.mean()
+        # log clocktime of methods for epoch
+        if (self.args.profiler is not None) and (self.args.log_profiler):
+            logging_dict.update(self.get_time_profile(key))
+        self.log_dict(logging_dict, prog_bar=True, logger=True)
+
+    def get_time_profile(self, key):
+        """Obtain trainer method times
+
+        Args:
+            key (str): one of ['train', 'val', 'test]
+
+        Returns:
+            dict: mean of clocktime of each method for past epoch
+        """
+        if key == "train":
+            num_steps = self.trainer.num_training_batches
+        if key == "val":
+            num_steps = self.trainer.num_val_batches[0]
+        if key == "test":
+            num_steps = self.trainer.num_test_batches[0]
+
+        time_profile = {}
+        for k, v in self.trainer.profiler.recorded_durations.items():
+            time_profile[k] = np.mean(v[-num_steps:])
+        return time_profile
+
+    def save_predictions(self, outputs):
+        """
+        Saves model predictions as pickle files
+            Makes a directory under /inference_dir/experiment_name/
+            Stores predictions for each sample individually under /inference_dir/experiment_name/sample_[sample_id].predictions
+
+        * Requires outputs to contain the keys ['sample_id']
+        """
+        experiment_name = (
+            os.path.splitext(os.path.basename(self.args.checkpoint_path))[0]
+            if (self.args.from_checkpoint and not self.args.train)
+            else self.args.experiment_name
+        )
+        for idx, sampleid in enumerate(outputs["sample_id"]):
+            sampledict = {
+                k: v[idx]
+                for k, v in outputs.items()
+                if (len(v) == len(outputs["sample_id"]))
+            }
+            if "nodeid2nodeidx" in outputs:
+                sampledict["nodeid2nodeidx"] = outputs["nodeid2nodeidx"]
+            for k, v in sampledict.items():
+                if isinstance(v, torch.Tensor) and v.is_cuda:
+                    sampledict[k] = v.cpu()
+            predictions_filename = os.path.join(
+                self.args.inference_dir,
+                experiment_name,
+                "sample_{}.predictions".format(sampleid),
+            )
+            dump_pickle(sampledict, predictions_filename)
+
+    def save_hiddens(self, outputs):
+        """
+        Saves the model's hidden layer outputs as pickle files
+            Makes a directory under /inference_dir/experiment_name/
+            Stores predictions for each sample individually under /inference_dir/experiment_name/sample_[sample_id].hiddens
+
+        * Requires outputs to contain the keys ['sample_id', 'hidden]
+        """
+        experiment_name = (
+            os.path.splitext(os.path.basename(self.args.checkpoint_path))[0]
+            if (self.args.from_checkpoint and not self.args.train)
+            else self.args.experiment_name
+        )
+        idx = outputs["sample_id"]
+        # hiddens = nn.functional.normalize(outputs['hidden'], dim = 1)
+        hiddens = [
+            {
+                k: v[i].cpu() if v.is_cuda else v[i]
+                for k, v in outputs.items()
+                if ("hidden" in k) and (len(v) == len(idx))
+            }
+            for i in range(len(idx))
+        ]
+        for i, h in zip(idx, hiddens):
+            predictions_filename = os.path.join(
+                self.args.inference_dir, experiment_name, "sample_{}.hiddens".format(i)
+            )
+            dump_pickle(h, predictions_filename)
+
+    def log_image(self, model_output, batch):
+        # log one sample from each epoch
+        sid = batch["sample_id"][0]
+        for k, v in model_output.items():
+            if "reconstruction" in k:
+                img = model_output[k][0].detach().cpu()
+                if img.shape[0] != 3:
+                    img = img.numpy()
+                    for cid, chan in enumerate(img):
+                        self.logger.log_image(
+                            chan,
+                            "Sample{}_{}_Chan{}_Epoch{}_Step{}".format(
+                                sid, k, cid, self.current_epoch, self.global_step
+                            ),
+                        )
+                else:
+                    img = img.permute(1, 2, 0).numpy()
+                    self.logger.log_image(
+                        img,
+                        "Sample{}_{}_Epoch{}_Step{}".format(
+                            sid, k, self.current_epoch, self.global_step
+                        ),
+                    )
+
+    @staticmethod
+    def add_args(parser) -> None:
+        """Add class specific args
+
+        Args:
+            parser (argparse.ArgumentParser): argument parser
+        """
+        parser.add_argument(
+            "--model_name",
+            type=str,
+            action=set_protgps_type("model"),
+            default="classifier",
+            help="Name of parent model",
+        )
+
+
+def gather_step_outputs(outputs):
+    """
+    Collates the dictionary outputs from each step into a single dictionary
+
+    Returns:
+        output_dict (dict): dictionary mapping step output keys to lists or tensors
+    """
+
+    output_dict = OrderedDict()
+    if isinstance(outputs[-1], list):  # adversarial setting with two optimizers
+        outputs = outputs[0]
+
+    for k in outputs[-1].keys():
+        if k == "preds_dict":
+            output_dict[k] = gather_step_outputs(
+                [output["preds_dict"] for output in outputs]
+            )
+        elif (
+            isinstance(outputs[-1][k], torch.Tensor) and len(outputs[-1][k].shape) == 0
+        ):
+            output_dict[k] = torch.stack([output[k] for output in outputs])
+        elif isinstance(outputs[-1][k], torch.Tensor):
+            output_dict[k] = torch.cat([output[k] for output in outputs], dim=0)
+        else:
+            output_dict[k] = [output[k] for output in outputs]
+    return output_dict
+
+
+def dump_pickle(file_obj, file_name):
+    """
+    Saves object as a binary pickle file
+        Creates directory of file
+        Saves file
+
+    Args:
+        file_obj: object
+        file_name: path to file
+    """
+    if not os.path.exists(os.path.dirname(file_name)):
+        try:
+            os.makedirs(os.path.dirname(file_name))
+        except OSError as exc:  # Guard against race condition
+            if exc.errno != exc.errno.EEXIST:
+                raise
+    pickle.dump(file_obj, open(file_name, "wb"))

data/protgps/loggers/comet.py

@@ -0,0 +1,25 @@
+from protgps.utils.registry import register_object
+import pytorch_lightning as pl
+import os
+from protgps.utils.classes import ProtGPS
+
+
+@register_object("comet", "logger")
+class COMET(pl.loggers.CometLogger, ProtGPS):
+    def __init__(self, args) -> None:
+        super().__init__(
+            api_key=os.environ.get("COMET_API_KEY"),
+            project_name=args.project_name,
+            experiment_name=args.experiment_name,
+            workspace=args.workspace,
+            log_env_details=True,
+            log_env_cpu=True,
+        )
+
+    def setup(self, **kwargs):
+        self.experiment.set_model_graph(kwargs["model"])
+        self.experiment.add_tags(kwargs["args"].logger_tags)
+        self.experiment.log_parameters(kwargs["args"])
+
+    def log_image(self, image, name):
+        self.experiment.log_image(image, name)

data/protgps/loggers/tensorboard.py

@@ -0,0 +1,25 @@
+from protgps.utils.registry import register_object
+import pytorch_lightning as pl
+import os
+from protgps.utils.classes import ProtGPS
+
+
+@register_object("tensorboard", "logger")
+class PLTensorBoardLogger(pl.loggers.TensorBoardLogger, ProtGPS):
+    def __init__(self, args) -> None:
+        super().__init__(args.logger_dir)
+
+    def setup(self, **kwargs):
+        pass
+
+    def log_image(self, image, name):
+        pass
+
+    @staticmethod
+    def add_args(parser) -> None:
+        parser.add_argument(
+            "--logger_dir",
+            type=str,
+            default=".",
+            help="directory to save tensorboard logs",
+        )

data/protgps/loggers/wandb.py

@@ -0,0 +1,25 @@
+from protgps.utils.registry import register_object
+import pytorch_lightning as pl
+import os
+from protgps.utils.classes import ProtGPS
+
+
+@register_object("wandb", "logger")
+class WandB(pl.loggers.WandbLogger, ProtGPS):
+    def __init__(self, args) -> None:
+        super().__init__(
+            project=args.project_name,
+            name=args.experiment_name,
+            entity=args.workspace,
+            tags = args.logger_tags
+        )
+
+    def setup(self, **kwargs):
+        # "gradients", "parameters", "all", or None
+        # # change "log_freq" log frequency of gradients and parameters (100 steps by default)
+        if kwargs["args"].local_rank == 0:
+            self.watch(kwargs["model"], log="all")
+            self.experiment.config.update(kwargs["args"])
+
+    def log_image(self, image, name):
+        self.log_image(images=[image], caption=[name])

data/protgps/models/abstract.py

@@ -0,0 +1,13 @@
+import torch.nn as nn
+from protgps.utils.classes import ProtGPS
+from abc import ABCMeta, abstractmethod
+
+# from efficientnet_pytorch import EfficientNet
+import math
+
+
+class AbstractModel(nn.Module, ProtGPS):
+    __metaclass__ = ABCMeta
+
+    def __init__(self):
+        super(AbstractModel, self).__init__()

data/protgps/models/classifier.py

@@ -0,0 +1,123 @@
+import torch
+import torch.nn as nn
+import copy
+from protgps.utils.registry import register_object, get_object
+from protgps.utils.classes import set_protgps_type
+from protgps.models.abstract import AbstractModel
+
+
+@register_object("classifier", "model")
+class Classifier(AbstractModel):
+    def __init__(self, args):
+        super(Classifier, self).__init__()
+
+        self.args = args
+        self.encoder = get_object(args.model_name_for_encoder, "model")(args)
+        cargs = copy.deepcopy(args)
+        self.mlp = get_object("mlp_classifier", "model")(cargs)
+
+    def forward(self, batch=None):
+        output = {}
+        output["encoder_hidden"] = self.encoder(batch)["hidden"]
+        output.update(self.mlp({"x": output["encoder_hidden"]}))
+        return output
+
+    @staticmethod
+    def add_args(parser) -> None:
+        """Add class specific args
+
+        Args:
+            parser (argparse.ArgumentParser): argument parser
+        """
+        parser.add_argument(
+            "--model_name_for_encoder",
+            type=str,
+            action=set_protgps_type("model"),
+            default="resnet18",
+            help="Name of encoder to use",
+        )
+        parser.add_argument(
+            "--mlp_input_dim", type=int, default=512, help="Dim of input to mlp"
+        )
+        parser.add_argument(
+            "--mlp_layer_configuration",
+            type=int,
+            nargs="*",
+            default=[128, 128],
+            help="MLP layer dimensions",
+        )
+        parser.add_argument(
+            "--mlp_use_batch_norm",
+            action="store_true",
+            default=False,
+            help="Use batchnorm in mlp",
+        )
+        parser.add_argument(
+            "--mlp_use_layer_norm",
+            action="store_true",
+            default=False,
+            help="Use LayerNorm in mlp",
+        )
+
+
+@register_object("mlp_classifier", "model")
+class MLPClassifier(AbstractModel):
+    def __init__(self, args):
+        super(MLPClassifier, self).__init__()
+
+        self.args = args
+
+        model_layers = []
+        cur_dim = args.mlp_input_dim
+        for layer_size in args.mlp_layer_configuration:
+            model_layers.extend(self.append_layer(cur_dim, layer_size, args))
+            cur_dim = layer_size
+
+        self.mlp = nn.Sequential(*model_layers)
+        self.predictor = nn.Linear(cur_dim, args.num_classes)
+
+    def append_layer(self, cur_dim, layer_size, args, with_dropout=True):
+        linear_layer = nn.Linear(cur_dim, layer_size)
+        bn = nn.BatchNorm1d(layer_size)
+        ln = nn.LayerNorm(layer_size)
+        if args.mlp_use_batch_norm:
+            seq = [linear_layer, bn, nn.ReLU()]
+        elif args.mlp_use_layer_norm:
+            seq = [linear_layer, ln, nn.ReLU()]
+        else:
+            seq = [linear_layer, nn.ReLU()]
+        if with_dropout:
+            seq.append(nn.Dropout(p=args.dropout))
+        return seq
+
+    def forward(self, batch=None):
+        output = {}
+        z = self.mlp(batch["x"])
+        output["logit"] = self.predictor(z)
+        output["hidden"] = z
+        return output
+
+    @staticmethod
+    def add_args(parser):
+        parser.add_argument(
+            "--mlp_input_dim", type=int, default=512, help="Dim of input to mlp"
+        )
+        parser.add_argument(
+            "--mlp_layer_configuration",
+            type=int,
+            nargs="*",
+            default=[128, 128],
+            help="MLP layer dimensions",
+        )
+        parser.add_argument(
+            "--mlp_use_batch_norm",
+            action="store_true",
+            default=False,
+            help="Use batchnorm in mlp",
+        )
+        parser.add_argument(
+            "--mlp_use_layer_norm",
+            action="store_true",
+            default=False,
+            help="Use LayerNorm in mlp",
+        )

data/protgps/models/fair_esm.py

@@ -0,0 +1,585 @@
+import torch
+import torch.nn as nn
+import copy
+from protgps.models.abstract import AbstractModel
+from protgps.utils.classes import set_protgps_type
+from protgps.utils.registry import register_object, get_object
+from torch.nn.utils.rnn import pad_sequence
+import functools
+
+
+@register_object("fair_esm", "model")
+class FairEsm(AbstractModel):
+    """
+    Refer to https://github.com/facebookresearch/esm#available-models
+    """
+
+    def __init__(self, args):
+        super(FairEsm, self).__init__()
+        self.args = args
+        torch.hub.set_dir(args.pretrained_hub_dir)
+        self.model, self.alphabet = torch.hub.load(
+            "facebookresearch/esm:main", args.esm_name
+        )
+        self.batch_converter = (
+            self.alphabet.get_batch_converter()
+        )  # TODO: Move to dataloader, so that we can batch in parallel
+        self.register_buffer("devicevar", torch.zeros(1, dtype=torch.int8))
+        if args.freeze_esm:
+            self.model.eval()
+
+        self.repr_layer = args.esm_hidden_layer
+        print("Using ESM hidden layers", self.repr_layer)
+
+    def forward(self, x, tokens=False, soft=False):
+        """
+        x: list of str (protein sequences)
+        tokens: tokenized or tensorized input
+        soft: embeddings precomputed
+        """
+        output = {}
+        if tokens:
+            batch_tokens = x.unsqueeze(0)
+        else:
+            fair_x = self.truncate_protein(x, self.args.max_prot_len)
+            batch_labels, batch_strs, batch_tokens = self.batch_converter(fair_x)
+
+        batch_tokens = batch_tokens.to(self.devicevar.device)
+
+        # use partial for cleanness
+        model_func = functools.partial(
+            self.model,
+            repr_layers=[self.repr_layer],
+            return_contacts=False,
+        )
+        if soft:
+            model_func = functools.partial(model_func, soft=soft)
+
+        if self.args.freeze_esm:
+            with torch.no_grad():
+                result = model_func(batch_tokens)
+        else:
+            result = model_func(batch_tokens)
+
+        # Generate per-sequence representations via averaging
+        hiddens = []
+        for sample_num, sample in enumerate(x):
+            # breakpoint()
+            hiddens.append(
+                result["representations"][self.repr_layer][
+                    sample_num, 1 : len(sample) + 1
+                ].mean(0)
+            )
+        if self.args.output_residue_hiddens:
+            output["residues"] = result["representations"][self.repr_layer]
+
+        output["hidden"] = torch.stack(hiddens)
+
+        return output
+
+    def truncate_protein(self, x, max_length=None):
+        # max length allowed is 1024
+        return [
+            (i, s[: max_length - 2])
+            if not isinstance(x[0], list)
+            else (i, s[0][: max_length - 2])
+            for i, s in enumerate(x)
+        ]
+
+    @staticmethod
+    def add_args(parser) -> None:
+        """Add class specific args
+
+        Args:
+            parser (argparse.ArgumentParser): argument parser
+        """
+        parser.add_argument(
+            "--pretrained_hub_dir",
+            type=str,
+            default="/home/protgps/esm_models",
+            help="directory to torch hub where pretrained models are saved",
+        )
+        parser.add_argument(
+            "--esm_name",
+            type=str,
+            default="esm2_t12_35M_UR50D",
+            help="directory to torch hub where pretrained models are saved",
+        )
+        parser.add_argument(
+            "--freeze_esm",
+            action="store_true",
+            default=False,
+            help="do not update encoder weights",
+        )
+        parser.add_argument(
+            "--esm_hidden_layer",
+            type=int,
+            default=12,
+            help="do not update encoder weights",
+        )
+        parser.add_argument(
+            "--output_residue_hiddens",
+            action="store_true",
+            default=False,
+            help="do not return residue-level hiddens, only sequence average",
+        )
+
+
+@register_object("fair_esm2", "model")
+class FairEsm2(FairEsm):
+    # def forward(self, x):
+    #     """
+    #     x: list of str (protein sequences)
+    #     """
+    #     output = {}
+    #     fair_x = self.truncate_protein(x)
+    #     batch_labels, batch_strs, batch_tokens = self.batch_converter(fair_x)
+    #     batch_tokens = batch_tokens.to(self.devicevar.device)
+
+    #     if self.args.freeze_esm:
+    #         with torch.no_grad():
+    #             result = self.model(
+    #                 batch_tokens, repr_layers=[self.repr_layer], return_contacts=False
+    #             )
+    #     else:
+    #         result = self.model(
+    #             batch_tokens, repr_layers=[self.repr_layer], return_contacts=False
+    #         )
+
+    #     # Generate per-sequence representations via averaging
+    #     hiddens = []
+    #     for sample_num, sample in enumerate(x):
+    #         hiddens.append(
+    #             result["representations"][self.repr_layer][
+    #                 sample_num, 1 : len(sample) + 1
+    #             ]
+    #         )
+    #     if self.args.output_residue_hiddens:
+    #         output["residues"] = result["representations"][self.repr_layer]
+
+    #     output["hidden"] = hiddens
+    #     return output
+
+    def truncate_protein(self, x, max_length=torch.inf):
+        return [
+            (i, s) if not isinstance(x[0], list) else (i, s[0]) for i, s in enumerate(x)
+        ]
+
+
+@register_object("fair_esm_fast", "model")
+class FairEsmFast(FairEsm):
+    def forward(self, x, tokens=False, soft=False):
+        """
+        x: list of str (protein sequences)
+        """
+        output = {}
+        if tokens:
+            batch_tokens = x.unsqueeze(0)
+        else:
+            fair_x = [(i, v) for i, v in enumerate(x)]
+            batch_labels, batch_strs, batch_tokens = self.batch_converter(fair_x)
+        batch_tokens = batch_tokens.to(self.devicevar.device)
+
+        # use partial for cleanness
+        model_func = functools.partial(
+            self.model,
+            repr_layers=[self.repr_layer],
+            return_contacts=False,
+        )
+        if soft:
+            model_func = functools.partial(model_func, soft=soft)
+
+        if self.args.freeze_esm:
+            with torch.no_grad():
+                result = model_func(batch_tokens)
+        else:
+            result = model_func(batch_tokens)
+
+        if self.args.output_residue_hiddens:
+            output["residues"] = result["representations"][self.repr_layer]
+
+        output["hidden"] = result["representations"][self.repr_layer].mean(axis=1)
+        return output
+
+
+import numpy as np
+
+
+@register_object("reverse_hom", "model")
+class ReverseHomology(FairEsm):
+    def forward(self, batch):
+        """
+        x: list of str (protein sequences)
+        """
+        output = {}
+        x = np.array(batch["x"]).reshape(-1, order="F")
+        fair_x = [(i, v) for i, v in enumerate(x)]
+        _, _, batch_tokens = self.batch_converter(fair_x)
+        batch_tokens = batch_tokens.to(self.devicevar.device)
+        if self.args.freeze_esm:
+            with torch.no_grad():
+                result = self.model(
+                    batch_tokens, repr_layers=[self.repr_layer], return_contacts=False
+                )
+        else:
+            result = self.model(
+                batch_tokens, repr_layers=[self.repr_layer], return_contacts=False
+            )
+        if self.args.output_residue_hiddens:
+            output["residues"] = result["representations"][self.repr_layer]
+
+        # NOTE: works for batch size of 1 only (otherwise need to reshape)
+        output["hidden"] = result["representations"][self.repr_layer].mean(axis=1)
+
+        return output
+
+
+@register_object("protein_encoder", "model")
+class ProteinEncoder(AbstractModel):
+    def __init__(self, args):
+        super(ProteinEncoder, self).__init__()
+        self.args = args
+        self.encoder = get_object(args.protein_encoder_type, "model")(args)
+        cargs = copy.deepcopy(args)
+        cargs.mlp_input_dim = args.protein_hidden_dim
+        args.freeze_esm = args.freeze_encoder
+        self.mlp = get_object(args.protein_classifer, "model")(cargs)
+        if self.args.freeze_encoder:
+            self.encoder.eval()
+
+    def forward(self, batch, tokens=False, soft=False):
+        output = {}
+        if self.args.freeze_encoder:
+            with torch.no_grad():
+                output_esm = self.encoder(batch["x"], tokens=tokens, soft=soft)
+        else:
+            output_esm = self.encoder(batch["x"], tokens=tokens, soft=soft)
+        # output["protein_hidden"] = output_esm["hidden"]
+        output.update(self.mlp({"x": output_esm["hidden"]}))
+        return output
+
+    @staticmethod
+    def add_args(parser) -> None:
+        """Add class specific args
+
+        Args:
+            parser (argparse.ArgumentParser): argument parser
+        """
+        parser.add_argument(
+            "--protein_encoder_type",
+            type=str,
+            default="fair_esm2",
+            help="name of the protein encoder",
+            action=set_protgps_type("model"),
+        )
+        parser.add_argument(
+            "--freeze_encoder",
+            action="store_true",
+            default=False,
+            help="do not update encoder weights",
+        )
+        parser.add_argument(
+            "--protein_hidden_dim",
+            type=int,
+            default=480,
+            help="hidden dimension of the protein",
+        )
+        parser.add_argument(
+            "--protein_classifer",
+            type=str,
+            default="mlp_classifier",
+            help="name of classifier",
+            action=set_protgps_type("model"),
+        )
+
+
+@register_object("protein_encoder_attention", "model")
+class ProteinEncoderAttention(ProteinEncoder):
+    def __init__(self, args):
+        super(ProteinEncoder, self).__init__()
+        self.args = args
+        self.encoder = get_object(args.protein_encoder_type, "model")(args)
+        cargs = copy.deepcopy(args)
+        cargs.mlp_input_dim = args.protein_hidden_dim
+        args.freeze_esm = args.freeze_encoder
+        self.mlp = get_object(args.protein_classifer, "model")(cargs)
+        if self.args.freeze_encoder:
+            self.encoder.eval()
+
+        heads = 8
+        encoder_layer = nn.TransformerEncoderLayer(
+            d_model=args.protein_hidden_dim, nhead=heads
+        )
+        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=6)
+
+    def forward(self, batch):
+        output = {}
+        if self.args.freeze_encoder:
+            with torch.no_grad():
+                output_esm = self.encoder(batch["x"])
+        else:
+            output_esm = self.encoder(batch["x"])
+
+        v_attention = []
+        for v in output_esm["hidden"]:
+            v = self.transformer_encoder(v)
+            v_attention.append(v.mean(0))
+
+        output.update(self.mlp({"x": torch.stack(v_attention)}))
+        return output
+
+
+@register_object("protein_encoder_esm_embeddings", "model")
+class ProteinEncoderESMEmbeddings(ProteinEncoder):
+    def forward(self, batch):
+        output = {}
+
+        fair_x = self.encoder.truncate_protein(batch["x"])
+        _, _, batch_tokens = self.encoder.batch_converter(fair_x)
+        batch_tokens = batch_tokens.to(self.encoder.devicevar.device)
+        esm_embedded = self.encoder.model.embed_tokens(batch_tokens).mean(1)
+
+        # output["protein_hidden"] = output_esm["hidden"]
+        output.update(self.mlp({"x": esm_embedded}))
+        return output
+
+
+@register_object("idr_encoder", "model")
+class IDREncoder(ProteinEncoder):
+    def forward(self, batch):
+        output = {}
+
+        if self.args.freeze_encoder:
+            with torch.no_grad():
+                idr_embeddings = self._forward_function(batch)
+        else:
+            idr_embeddings = self._forward_function(batch)
+
+        output.update(self.mlp({"x": torch.stack(idr_embeddings)}))
+        return output
+
+    def _forward_function(self, batch) -> list:
+        output_esm = self.encoder(batch["x"])
+        # mask out non-idr residues and average
+        B, N, H = output_esm["residues"].shape
+        mask = torch.zeros(B, N)
+        for i in range(B):
+            mask[i, batch["start_idx"][i] : batch["end_idx"][i]] = 1
+
+        idr_residue_embeddings = output_esm["residues"] * mask.unsqueeze(-1).to(
+            output_esm["residues"].device
+        )
+        idr_embeddings = []
+        for idx, sample in enumerate(idr_residue_embeddings):
+            avg_sample = sample.sum(0) / mask[idx].sum()
+            idr_embeddings.append(avg_sample)
+
+        return idr_embeddings
+
+    @staticmethod
+    def set_args(args) -> None:
+        args.output_residue_hiddens = True
+
+
+@register_object("all_idr_encoder", "model")
+class AllIDREncoder(ProteinEncoder):
+    def forward(self, batch):
+        output = {}
+
+        if self.args.freeze_encoder:
+            with torch.no_grad():
+                idr_embeddings = self._forward_function(batch)
+        else:
+            idr_embeddings = self._forward_function(batch)
+
+        output.update(self.mlp({"x": torch.stack(idr_embeddings)}))
+        return output
+
+    def _forward_function(self, batch) -> list:
+        output_esm = self.encoder(batch["x"])
+
+        # mask out non-idr residues and average
+        B, N, H = output_esm["residues"].shape
+        mask = torch.zeros(B, N)
+
+        for i in range(B):
+            start_indices = [int(n) for n in batch["start_indices"][i].split("_")]
+            end_indices = [int(n) for n in batch["end_indices"][i].split("_")]
+            for idr_idx in range(len(start_indices)):
+                mask[i, start_indices[idr_idx] : end_indices[idr_idx]] = 1
+
+        idr_residue_embeddings = output_esm["residues"] * mask.unsqueeze(-1).to(
+            output_esm["residues"].device
+        )
+        idr_embeddings = []
+        for idx, sample in enumerate(idr_residue_embeddings):
+            avg_sample = sample.sum(0) / mask[idx].sum()
+            idr_embeddings.append(avg_sample)
+
+        return idr_embeddings
+
+    @staticmethod
+    def set_args(args) -> None:
+        args.output_residue_hiddens = True
+
+
+@register_object("all_idr_esm_embeddings_encoder", "model")
+class AllIDRESMEmbeddingsEncoder(ProteinEncoder):
+    def forward(self, batch):
+        output = {}
+
+        fair_x = self.encoder.truncate_protein(batch["x"])
+        _, _, batch_tokens = self.encoder.batch_converter(fair_x)
+        batch_tokens = batch_tokens.to(self.encoder.devicevar.device)
+        esm_embedded = self.encoder.model.embed_tokens(batch_tokens)
+
+        # mask out non-idr residues and average
+        B, N, H = esm_embedded.shape
+        mask = torch.zeros(B, N)
+
+        for i in range(B):
+            start_indices = [int(n) for n in batch["start_indices"][i].split("_")]
+            end_indices = [int(n) for n in batch["end_indices"][i].split("_")]
+            for idr_idx in range(len(start_indices)):
+                mask[i, start_indices[idr_idx] : end_indices[idr_idx]] = 1
+
+        idr_residue_embeddings = esm_embedded * mask.unsqueeze(-1).to(
+            esm_embedded.device
+        )
+        idr_embeddings = []
+        for idx, sample in enumerate(idr_residue_embeddings):
+            avg_sample = sample.sum(0) / mask[idx].sum()
+            idr_embeddings.append(avg_sample)
+
+        output.update(self.mlp({"x": torch.stack(idr_embeddings)}))
+        return output
+
+
+@register_object("all_not_idr_esm_embeddings_encoder", "model")
+class AllNotIDRESMEmbeddingsEncoder(ProteinEncoder):
+    def forward(self, batch):
+        output = {}
+
+        fair_x = self.encoder.truncate_protein(batch["x"])
+        _, _, batch_tokens = self.encoder.batch_converter(fair_x)
+        batch_tokens = batch_tokens.to(self.encoder.devicevar.device)
+        esm_embedded = self.encoder.model.embed_tokens(batch_tokens)
+
+        # mask out non-idr residues and average
+        B, N, H = esm_embedded.shape
+        mask = torch.ones(B, N)
+
+        for i in range(B):
+            start_indices = [int(n) for n in batch["start_indices"][i].split("_")]
+            end_indices = [int(n) for n in batch["end_indices"][i].split("_")]
+            for idr_idx in range(len(start_indices)):
+                mask[i, start_indices[idr_idx] : end_indices[idr_idx]] = 0
+
+        idr_residue_embeddings = esm_embedded * mask.unsqueeze(-1).to(
+            esm_embedded.device
+        )
+        idr_embeddings = []
+        for idx, sample in enumerate(idr_residue_embeddings):
+            avg_sample = sample.sum(0) / mask[idx].sum()
+            idr_embeddings.append(avg_sample)
+
+        output.update(self.mlp({"x": torch.stack(idr_embeddings)}))
+        return output
+
+
+@register_object("all_not_idr_encoder", "model")
+class AllNotIDREncoder(AllIDREncoder):
+    def _forward_function(self, batch) -> list:
+        output_esm = self.encoder(batch["x"])
+
+        # mask out non-idr residues and average
+        B, N, H = output_esm["residues"].shape
+        mask = torch.ones(B, N)
+
+        for i in range(B):
+            start_indices = [int(n) for n in batch["start_indices"][i].split("_")]
+            end_indices = [int(n) for n in batch["end_indices"][i].split("_")]
+            for idr_idx in range(len(start_indices)):
+                mask[i, start_indices[idr_idx] : end_indices[idr_idx]] = 0
+
+        idr_residue_embeddings = output_esm["residues"] * mask.unsqueeze(-1).to(
+            output_esm["residues"].device
+        )
+        idr_embeddings = []
+        for idx, sample in enumerate(idr_residue_embeddings):
+            avg_sample = sample.sum(0) / mask[idx].sum()
+            idr_embeddings.append(avg_sample)
+
+        return idr_embeddings
+
+
+@register_object("context_idr_hiddens", "model")
+class ContextIDREncoder(ProteinEncoder):
+    def forward(self, batch):
+        output = {}
+
+        if self.args.freeze_encoder:
+            with torch.no_grad():
+                idr_embeddings = self._forward_function(batch)
+        else:
+            idr_embeddings
+
+        output["hidden"] = torch.stack(idr_embeddings)
+        return output
+
+    def _forward_function(self, batch) -> list:
+        output_esm = self.encoder(batch["x"])
+        # mask out non-idr residues and average
+        B, N, H = output_esm["residues"].shape
+        mask = torch.zeros(B, N)
+        for i in range(B):
+            mask[i, batch["start_idx"][i] : batch["end_idx"][i]] = 1
+
+        idr_residue_embeddings = output_esm["residues"] * mask.unsqueeze(-1).to(
+            output_esm["residues"].device
+        )
+        idr_embeddings = []
+        for idx, sample in enumerate(idr_residue_embeddings):
+            avg_sample = sample.sum(0) / mask[idx].sum()
+            idr_embeddings.append(avg_sample)
+
+        return idr_embeddings
+
+    @staticmethod
+    def set_args(args) -> None:
+        args.output_residue_hiddens = True
+
+
+@register_object("fair_esm_hiddens", "model")
+class FairEsmHiddens(AbstractModel):
+    def __init__(self, args):
+        super(FairEsmHiddens, self).__init__()
+        self.args = args
+        self.encoder = get_object(args.fair_esm_type, "model")(args)
+        if self.args.freeze_esm:
+            self.encoder.eval()
+
+    def forward(self, batch):
+        output = {}
+        if self.args.freeze_esm:
+            with torch.no_grad():
+                output_esm = self.encoder(batch["x"])
+        else:
+            output_esm = self.encoder(batch["x"])
+
+        return output_esm
+
+    @staticmethod
+    def add_args(parser) -> None:
+        """Add class specific args
+
+        Args:
+            parser (argparse.ArgumentParser): argument parser
+        """
+        parser.add_argument(
+            "--fair_esm_type",
+            type=str,
+            default="fair_esm2",
+            help="name of the protein encoder",
+            action=set_protgps_type("model"),
+        )

data/protgps/utils/callbacks.py

@@ -0,0 +1,57 @@
+from pytorch_lightning.callbacks import Callback
+from protgps.utils.registry import get_object
+
+
+def set_callbacks(trainer, args):
+    """
+    Set callbacks for trainer, taking into consideration callbacks already set by trainer args.
+    Callbacks that are preset by args and perform the same function as those manually selected
+    are removed by comparing parent classes between callbacks.
+
+    Parameters
+    ----------
+    trainer : pl.Trainer
+        lightning trainer
+    args : Namespace
+        global args
+
+    Returns
+    -------
+    callbacks: list
+        complete list of callbacks to be used by trainer
+    """
+    callbacks = []
+    for cback in args.callback_names:
+        callbacks.append(get_object(cback, "callback")(args))
+
+    # remove callbacks that are set manually
+    redundant_callbacks = []
+    for cback in trainer.callbacks:
+        parent_cls_preset = get_callback_parent_class(cback)
+        for new_cback in callbacks:
+            parent_cls_postset = get_callback_parent_class(new_cback)
+            if parent_cls_preset == parent_cls_postset:
+                redundant_callbacks.append(cback)
+
+    for cback in trainer.callbacks:
+        if cback not in redundant_callbacks:
+            callbacks.append(cback)
+
+    return callbacks
+
+
+def get_callback_parent_class(obj):
+    """
+    Parameters
+    ----------
+    obj : Callback
+        instance of a callback class
+
+    Returns
+    -------
+    class
+        parent class of callback that is the first child of the Callback class
+    """
+    parent_id = [cls == Callback for cls in obj.__class__.__mro__].index(True)
+    parent_cls = obj.__class__.__mro__[parent_id - 1]
+    return parent_cls

data/protgps/utils/classes.py

@@ -0,0 +1,126 @@
+from abc import ABCMeta
+import argparse
+from protgps.utils.registry import get_object
+
+INITED_OBJ = []
+
+
+class classproperty(object):
+    """
+    Method decorator behaves as @classmethod + @property
+    """
+
+    def __init__(self, fget):
+        self.fget = fget
+
+    def __get__(self, owner_self, owner_cls):
+        return self.fget(owner_cls)
+
+
+class ProtGPS(object):
+    __metaclass__ = ABCMeta
+
+    def __init__(self, **kwargs) -> None:
+        super(ProtGPS, self).__init__()
+
+    @staticmethod
+    def add_args(parser) -> None:
+        """Add class specific args
+
+        Args:
+            parser (argparse.ArgumentParser): argument parser
+        """
+        pass
+
+    @staticmethod
+    def set_args(args) -> None:
+        """Set values for class specific args
+
+        Args:
+            args (argparse.Namespace): arguments
+        """
+        pass
+
+
+def set_protgps_type(object_name):
+    """
+    Build argparse action class for registry items
+    Used to add and set object-level args
+
+    Args:
+        object_name (str): kind of protgps class uses (e.g., dataset, model, lightning)
+
+    Returns:
+        argparse.Action: action for specific protgps class
+    """
+
+    class ProtGPSAction(argparse.Action):
+        def __init__(
+            self,
+            option_strings,
+            dest,
+            nargs=None,
+            const=None,
+            default=None,
+            type=None,
+            choices=None,
+            required=False,
+            help=None,
+            metavar=None,
+        ):
+            super().__init__(
+                option_strings=option_strings,
+                dest=dest,
+                nargs=nargs,
+                const=const,
+                default=default,
+                type=type,
+                choices=choices,
+                required=required,
+                help=help,
+                metavar=metavar,
+            )
+            self.is_protgps_action = True
+            self.object_name = object_name
+
+        def __call__(self, parser, namespace, values, option_string=None) -> None:
+            setattr(namespace, self.dest, values)
+
+        def add_args(self, parser, values) -> None:
+            """
+            Add object-level args when an add_argument is called
+
+            Args:
+                parser (argparse.parser): protgps parser object
+                values (Union[list, str]): argument values inputted
+            """
+            if isinstance(values, list):
+                for v in values:
+                    obj_val_str = f"{v}_{object_name}"
+                    # if object has already been called, conflict arises with add parse called multiple times
+                    if obj_val_str not in INITED_OBJ:
+                        get_object(v, object_name).add_args(parser)
+                        INITED_OBJ.append(obj_val_str)
+
+            elif isinstance(values, str):
+                obj_val_str = f"{values}_{object_name}"
+                # if object has already been called, conflict arises with add parse called multiple times
+                if obj_val_str not in INITED_OBJ:
+                    get_object(values, object_name).add_args(parser)
+                    INITED_OBJ.append(obj_val_str)
+
+        def set_args(self, args, val) -> None:
+            """
+            Call object-level set_args method
+
+            Args:
+                args (argparse.namespace): global args
+                val (Union[list,str]): value for argument
+            """
+            if isinstance(val, list):
+                for v in val:
+                    get_object(v, object_name).set_args(args)
+            elif isinstance(val, str):
+                get_object(val, object_name).set_args(args)
+
+    return ProtGPSAction

data/protgps/utils/debug.py

@@ -0,0 +1,13 @@
+def debug_vscode():
+    """
+    Since this requires listening on a local port, this will only work when VSCode is connected to the same machine.
+    Before running, add the following to your launch.json:
+        {"version":"0.2.0","configurations":[{"name":"Python: Remote Attach","type":"python","request":"attach","connect":{"host":"localhost","port":5678},"pathMappings":[{"localRoot":"${workspaceFolder}",
+        "remoteRoot":"."}],"justMyCode":true}]}
+    """
+    import debugpy
+
+    print("Waiting for VSCode debugger to attach...")
+    debugpy.listen(5678)
+    debugpy.wait_for_client()
+    print("VSCode debugger attached!")

data/protgps/utils/download.py

@@ -0,0 +1,37 @@
+# Code taken from
+# https://stackoverflow.com/questions/38511444/python-download-files-from-google-drive-using-url
+
+
+import requests
+
+
+def download_file_from_google_drive(id, destination):
+    URL = "https://docs.google.com/uc?export=download"
+
+    session = requests.Session()
+
+    response = session.get(URL, params={"id": id}, stream=True)
+    token = get_confirm_token(response)
+
+    if token:
+        params = {"id": id, "confirm": token}
+        response = session.get(URL, params=params, stream=True)
+
+    save_response_content(response, destination)
+
+
+def get_confirm_token(response):
+    for key, value in response.cookies.items():
+        if key.startswith("download_warning"):
+            return value
+
+    return None
+
+
+def save_response_content(response, destination):
+    CHUNK_SIZE = 32768
+
+    with open(destination, "wb") as f:
+        for chunk in response.iter_content(CHUNK_SIZE):
+            if chunk:  # filter out keep-alive new chunks
+                f.write(chunk)

data/protgps/utils/loading.py

@@ -0,0 +1,235 @@
+from argparse import Namespace, FileType
+import pickle
+import collections.abc as container_abcs
+import re
+from tabnanny import check
+from typing import Literal, Optional
+from protgps.utils.registry import get_object
+import torch
+from torch.utils import data
+from protgps.utils.sampler import DistributedWeightedSampler
+from pytorch_lightning.utilities.cloud_io import load as pl_load
+
+
+string_classes = (str, bytes)
+int_classes = int
+np_str_obj_array_pattern = re.compile(r"[SaUO]")
+
+default_collate_err_msg_format = (
+    "default_collate: batch must contain tensors, numpy arrays, numbers, PyG Data or HeteroData, "
+    "dicts, or lists; found {}"
+)
+
+
+def default_collate(batch):
+    r"""Puts each data field into a tensor with outer dimension batch size"""
+
+    elem = batch[0]
+    elem_type = type(elem)
+    if isinstance(elem, torch.Tensor):
+        out = None
+        if torch.utils.data.get_worker_info() is not None:
+            # If we're in a background process, concatenate directly into a
+            # shared memory tensor to avoid an extra copy
+            numel = sum([x.numel() for x in batch])
+            storage = elem._typed_storage()._new_shared(numel, device=elem.device)
+            out = elem.new(storage).view(-1, *list(elem.size()))
+        return torch.stack(batch, 0, out=out)
+    elif (
+        elem_type.__module__ == "numpy"
+        and elem_type.__name__ != "str_"
+        and elem_type.__name__ != "string_"
+    ):
+        if elem_type.__name__ == "ndarray" or elem_type.__name__ == "memmap":
+            # array of string classes and object
+            if np_str_obj_array_pattern.search(elem.dtype.str) is not None:
+                raise TypeError(default_collate_err_msg_format.format(elem.dtype))
+
+            return default_collate([torch.as_tensor(b) for b in batch])
+        elif elem.shape == ():  # scalars
+            return torch.as_tensor(batch)
+    elif isinstance(elem, float):
+        return torch.tensor(batch, dtype=torch.float64)
+    elif isinstance(elem, int_classes):
+        return torch.tensor(batch)
+    elif isinstance(elem, string_classes):
+        return batch
+    elif isinstance(elem, container_abcs.Mapping):
+        return {key: default_collate([d[key] for d in batch]) for key in elem}
+    elif isinstance(elem, tuple) and hasattr(elem, "_fields"):  # namedtuple
+        return elem_type(*(default_collate(samples) for samples in zip(*batch)))
+    elif isinstance(elem, container_abcs.Sequence):
+        # check to make sure that the elements in batch have consistent size
+        it = iter(batch)
+        elem_size = len(next(it))
+        if not all(len(elem) == elem_size for elem in it):
+            raise RuntimeError("each element in list of batch should be of equal size")
+        transposed = zip(*batch)
+        return [default_collate(samples) for samples in transposed]
+
+    raise TypeError(default_collate_err_msg_format.format(elem_type))
+
+
+def ignore_None_collate(batch):
+    """
+    default_collate wrapper that creates batches only of not None values.
+    Useful for cases when the dataset.__getitem__ can return None because of some
+    exception and then we will want to exclude that sample from the batch.
+    """
+    batch = [x for x in batch if x is not None]
+    if len(batch) == 0:
+        return None
+    return default_collate(batch)
+
+
+def get_train_dataset_loader(args: Namespace, split: Optional[str] = "train"):
+    """Given arg configuration, return appropriate torch.DataLoader
+    for train data loader
+
+    Args:
+        args (Namespace): args
+        split (str, optional): dataset split. Defaults to "train".
+
+    Returns:
+        train_data_loader: iterator that returns batches
+    """
+    train_data = get_object(args.dataset_name, "dataset")(args, split)
+
+    if args.class_bal:
+        if args.strategy == "ddp":
+            sampler = DistributedWeightedSampler(
+                train_data,
+                weights=train_data.weights,
+                replacement=True,
+                rank=args.global_rank,
+                num_replicas=args.world_size,
+            )
+        else:
+            sampler = data.sampler.WeightedRandomSampler(
+                weights=train_data.weights,
+                num_samples=len(train_data),
+                replacement=True,
+            )
+    else:
+        if args.strategy == "ddp":
+            sampler = torch.utils.data.distributed.DistributedSampler(
+                train_data,
+                shuffle=True,
+                rank=args.global_rank,
+                num_replicas=args.world_size,
+            )
+        else:
+            sampler = data.sampler.RandomSampler(train_data)
+
+    train_data_loader = data.DataLoader(
+        train_data,
+        num_workers=args.num_workers,
+        sampler=sampler,
+        pin_memory=True,
+        batch_size=args.batch_size,
+        collate_fn=ignore_None_collate,
+        drop_last=True,
+    )
+
+    return train_data_loader
+
+
+def get_eval_dataset_loader(
+    args: Namespace, split: Literal["train", "dev", "test"], shuffle=False
+):
+    """_summary_
+
+    Args:
+        args (Namespace): args
+        split (Literal["train", "dev", "test"]): dataset split.
+        shuffle (bool, optional): whether to shuffle dataset. Defaults to False.
+
+    Returns:
+        data_loader: iterator that returns batches
+    """
+
+    eval_data = get_object(args.dataset_name, "dataset")(args, split)
+
+    if args.strategy == "ddp":
+        sampler = torch.utils.data.distributed.DistributedSampler(
+            eval_data,
+            shuffle=shuffle,
+            rank=args.global_rank,
+            num_replicas=args.world_size,
+        )
+    else:
+        sampler = (
+            torch.utils.data.sampler.RandomSampler(eval_data)
+            if shuffle
+            else torch.utils.data.sampler.SequentialSampler(eval_data)
+        )
+    data_loader = torch.utils.data.DataLoader(
+        eval_data,
+        batch_size=args.batch_size,
+        num_workers=args.num_workers,
+        collate_fn=ignore_None_collate,
+        pin_memory=True,
+        drop_last=False,
+        sampler=sampler,
+    )
+
+    return data_loader
+
+
+@torch.no_grad()
+def concat_all_gather(tensor):
+    """
+    Performs all_gather operation on the provided tensors.
+    *** Warning ***: torch.distributed.all_gather has no gradient.
+    """
+
+    tensors_gather = [
+        torch.ones_like(tensor) for _ in range(torch.distributed.get_world_size())
+    ]
+    torch.distributed.all_gather(tensors_gather, tensor, async_op=False)
+    output = torch.cat(tensors_gather, dim=0)
+    return output
+
+
+def get_lightning_model(args: Namespace):
+    """Create new model or load from checkpoint
+
+    Args:
+        args (Namespace): global args
+
+    Raises:
+        FileType: checkpoint_path must be ".args" or ".ckpt" file
+
+    Returns:
+        model: pl.LightningModule instance
+    """
+    if args.from_checkpoint:
+        if args.checkpoint_path.endswith(".args"):
+            snargs = Namespace(**pickle.load(open(args.checkpoint_path, "rb")))
+            # update saved args with new arguments
+            for k, v in vars(args).items():
+                if k not in snargs:
+                    setattr(snargs, k, v)
+            model = get_object(snargs.lightning_name, "lightning")(snargs)
+            modelpath = snargs.model_path
+        elif args.checkpoint_path.endswith(".ckpt"):
+            model = get_object(args.lightning_name, "lightning")(args)
+            modelpath = args.checkpoint_path
+            checkpoint = pl_load(
+                args.checkpoint_path, map_location=lambda storage, loc: storage
+            )
+            snargs = checkpoint["hyper_parameters"]["args"]
+        else:
+            raise FileType("checkpoint_path should be an args or ckpt file.")
+        # update args with old args if not found
+        for k, v in vars(snargs).items():
+            if k not in args:
+                setattr(args, k, v)
+        model = model.load_from_checkpoint(
+            checkpoint_path=modelpath,
+            strict=not args.relax_checkpoint_matching,
+            **{"args": args},
+        )
+    else:
+        model = get_object(args.lightning_name, "lightning")(args)
+    return model

data/protgps/utils/messages.py

@@ -0,0 +1,3 @@
+# Error Messages
+METAFILE_NOTFOUND_ERR = "Metadata file {} could not be parsed! Exception: {}!"
+LOAD_FAIL_MSG = "Failed to load image: {}\nException: {}"

data/protgps/utils/parsing.py

@@ -0,0 +1,597 @@
+import argparse
+import os
+import pwd
+from pytorch_lightning import Trainer
+import itertools
+from protgps.utils.registry import md5
+import json
+import copy
+from protgps.utils.classes import set_protgps_type
+
+EMPTY_NAME_ERR = 'Name of augmentation or one of its arguments cant be empty\n\
+                  Use "name/arg1=value/arg2=value" format'
+POSS_VAL_NOT_LIST = (
+    "Flag {} has an invalid list of values: {}. Length of list must be >=1"
+)
+
+
+class GlobalNamespace(argparse.Namespace):
+    pass
+
+
+def parse_dispatcher_config(config):
+    """
+    Parses an experiment config, and creates jobs. For flags that are expected to be a single item,
+    but the config contains a list, this will return one job for each item in the list.
+    :config - experiment_config
+
+    returns: jobs - a list of flag strings, each of which encapsulates one job.
+         *Example: --train --cuda --dropout=0.1 ...
+    returns: experiment_axies - axies that the grid search is searching over
+    """
+
+    assert all(
+        [
+            k
+            in [
+                "script",
+                "available_gpus",
+                "cartesian_hyperparams",
+                "paired_hyperparams",
+                "tune_hyperparams",
+            ]
+            for k in config.keys()
+        ]
+    )
+
+    cartesian_hyperparamss = config["cartesian_hyperparams"]
+    paired_hyperparams = config.get("paired_hyperparams", [])
+    flags = []
+    arguments = []
+    experiment_axies = []
+
+    # add anything outside search space as fixed
+    fixed_args = ""
+    for arg in config:
+        if arg not in [
+            "script",
+            "cartesian_hyperparams",
+            "paired_hyperparams",
+            "available_gpus",
+        ]:
+            if type(config[arg]) is bool:
+                if config[arg]:
+                    fixed_args += "--{} ".format(str(arg))
+                else:
+                    continue
+            else:
+                fixed_args += "--{} {} ".format(arg, config[arg])
+
+    # add paired combo of search space
+    paired_args_list = [""]
+    if len(paired_hyperparams) > 0:
+        paired_args_list = []
+        paired_keys = list(paired_hyperparams.keys())
+        paired_vals = list(paired_hyperparams.values())
+        flags.extend(paired_keys)
+        for paired_combo in zip(*paired_vals):
+            paired_args = ""
+            for i, flg_value in enumerate(paired_combo):
+                if type(flg_value) is bool:
+                    if flg_value:
+                        paired_args += "--{} ".format(str(paired_keys[i]))
+                    else:
+                        continue
+                else:
+                    paired_args += "--{} {} ".format(
+                        str(paired_keys[i]), str(flg_value)
+                    )
+            paired_args_list.append(paired_args)
+
+    # add every combo of search space
+    product_flags = []
+    for key, value in cartesian_hyperparamss.items():
+        flags.append(key)
+        product_flags.append(key)
+        arguments.append(value)
+        if len(value) > 1:
+            experiment_axies.append(key)
+
+    experiments = []
+    exps_combs = list(itertools.product(*arguments))
+
+    for tpl in exps_combs:
+        exp = ""
+        for idx, flg in enumerate(product_flags):
+            if type(tpl[idx]) is bool:
+                if tpl[idx]:
+                    exp += "--{} ".format(str(flg))
+                else:
+                    continue
+            else:
+                exp += "--{} {} ".format(str(flg), str(tpl[idx]))
+        exp += fixed_args
+        for paired_args in paired_args_list:
+            experiments.append(exp + paired_args)
+
+    return experiments, flags, experiment_axies
+
+
+def prepare_training_config_for_eval(train_config):
+    """Convert training config to an eval config for testing.
+
+    Parameters
+    ----------
+    train_config: dict
+         config with the following structure:
+              {
+                   "train_config": ,   # path to train config
+                   "log_dir": ,        # log directory used by dispatcher during training
+                   "eval_args": {}     # test set-specific arguments beyond default
+              }
+
+    Returns
+    -------
+    experiments: list
+    flags: list
+    experiment_axies: list
+    """
+
+    train_args = json.load(open(train_config["train_config"], "r"))
+
+    experiments, _, _ = parse_dispatcher_config(train_args)
+    stem_names = [md5(e) for e in experiments]
+    eval_args = copy.deepcopy(train_args)
+    eval_args["cartesian_hyperparams"].update(train_config["eval_args"])
+
+    # reset defaults
+    eval_args["cartesian_hyperparams"]["train"] = [False]
+    eval_args["cartesian_hyperparams"]["test"] = [True]
+    eval_args["cartesian_hyperparams"]["from_checkpoint"] = [True]
+    eval_args["cartesian_hyperparams"]["gpus"] = [1]
+    # eval_args["cartesian_hyperparams"]["comet_tags"][0] += " eval"
+    eval_args["available_gpus"] = train_config["available_gpus"]
+    eval_args["script"] = train_config["script"]
+
+    experiments, flags, experiment_axies = parse_dispatcher_config(eval_args)
+
+    if ("checkpoint_path" not in eval_args["cartesian_hyperparams"]) or (
+        "checkpoint_path" in train_args["cartesian_hyperparams"]
+    ):
+        for (idx, e), s in zip(enumerate(experiments), stem_names):
+            experiments[idx] += " --checkpoint_path {}".format(
+                os.path.join(train_config["log_dir"], "{}.args".format(s))
+            )
+
+    return experiments, flags, experiment_axies
+
+
+def get_parser():
+    global_namespace = GlobalNamespace(allow_abbrev=False)
+
+    parser = argparse.ArgumentParser(
+        description="ProtGPS Standard Args.", allow_abbrev=False
+    )
+
+    # -------------------------------------
+    # Run Setup
+    # -------------------------------------
+    parser.add_argument(
+        "--train",
+        action="store_true",
+        default=False,
+        help="Whether or not to train model",
+    )
+    parser.add_argument(
+        "--dev",
+        action="store_true",
+        default=False,
+        help="Whether or not to run model on dev set",
+    )
+    parser.add_argument(
+        "--test",
+        action="store_true",
+        default=False,
+        help="Whether or not to run model on test set",
+    )
+    parser.add_argument(
+        "--predict",
+        action="store_true",
+        default=False,
+        help="Whether to run model for pure prediction where labels are not known",
+    )
+    parser.add_argument(
+        "--eval_on_train",
+        action="store_true",
+        default=False,
+        help="Whether or not to evaluate model on train split",
+    )
+
+    # -------------------------------------
+    # Data
+    # -------------------------------------
+    parser.add_argument(
+        "--dataset_name",
+        type=str,
+        action=set_protgps_type("dataset"),
+        default="mnist",
+        help="Name of dataset",
+    )
+    parser.add_argument(
+        "--img_size",
+        type=int,
+        nargs="+",
+        default=[256, 256],
+        help="Width and height of image in pixels. [default: [256,256]]",
+    )
+    parser.add_argument(
+        "--num_chan", type=int, default=3, help="Number of channels for input image"
+    )
+    parser.add_argument(
+        "--img_mean",
+        type=float,
+        nargs="+",
+        default=[128.1722],
+        help="Mean of image per channel",
+    )
+    parser.add_argument(
+        "--img_std",
+        type=float,
+        nargs="+",
+        default=[87.1849],
+        help="Standard deviation  of image per channel",
+    )
+    parser.add_argument(
+        "--img_file_type",
+        type=str,
+        default="png",
+        choices=["png", "dicom"],
+        help="Type of image. one of [png, dicom]",
+    )
+
+    # -------------------------------------
+    # Losses
+    # -------------------------------------
+
+    # losses and metrics
+    parser.add_argument(
+        "--loss_names",
+        type=str,
+        action=set_protgps_type("loss"),
+        nargs="*",
+        default=[],
+        help="Name of loss",
+    )
+    parser.add_argument(
+        "--loss_names_for_eval",
+        type=str,
+        action=set_protgps_type("loss"),
+        nargs="*",
+        default=None,
+        help="Name of loss",
+    )
+
+    # -------------------------------------
+    # Metrics
+    # -------------------------------------
+
+    parser.add_argument(
+        "--metric_names",
+        type=str,
+        action=set_protgps_type("metric"),
+        nargs="*",
+        default=[],
+        help="Name of performance metric",
+    )
+
+    # -------------------------------------
+    # Training Module
+    # -------------------------------------
+
+    parser.add_argument(
+        "--lightning_name",
+        type=str,
+        action=set_protgps_type("lightning"),
+        default="base",
+        help="Name of lightning module",
+    )
+
+    # -------------------------------------
+    # Hyper parameters
+    # -------------------------------------
+    # learning
+    parser.add_argument(
+        "--batch_size",
+        type=int,
+        default=32,
+        help="Batch size for training [default: 128]",
+    )
+    parser.add_argument(
+        "--lr",
+        type=float,
+        default=0.001,
+        help="Initial learning rate [default: 0.001]",
+    )
+    parser.add_argument(
+        "--dropout",
+        type=float,
+        default=0.25,
+        help="Amount of dropout to apply on last hidden layer [default: 0.25]",
+    )
+    parser.add_argument(
+        "--optimizer_name",
+        type=str,
+        action=set_protgps_type("optimizer"),
+        default="adam",
+        help="Optimizer to use [default: adam]",
+    )
+    parser.add_argument(
+        "--momentum", type=float, default=0, help="Momentum to use with SGD"
+    )
+    parser.add_argument(
+        "--lr_decay",
+        type=float,
+        default=0.1,
+        help="Initial learning rate [default: 0.5]",
+    )
+    parser.add_argument(
+        "--weight_decay",
+        type=float,
+        default=0,
+        help="L2 Regularization penaty [default: 0]",
+    )
+
+    # tune
+    parser.add_argument(
+        "--tune_hyperopt",
+        action="store_true",
+        default=False,
+        help="Whether to run hyper-parameter optimization",
+    )
+    parser.add_argument(
+        "--tune_search_alg",
+        type=str,
+        default="search",
+        help="Optimization algorithm",
+    )
+    parser.add_argument(
+        "--tune_hyperparam_names",
+        type=str,
+        nargs="*",
+        default=[],
+        help="Name of parameters being optimized",
+    )
+
+    # -------------------------------------
+    # Schedule
+    # -------------------------------------
+    parser.add_argument(
+        "--scheduler_name",
+        type=str,
+        action=set_protgps_type("scheduler"),
+        default="reduce_on_plateau",
+        help="Name of scheduler",
+    )
+    parser.add_argument(
+        "--cosine_annealing_period",
+        type=int,
+        default=10,
+        help="length of period of lr cosine anneal",
+    )
+    parser.add_argument(
+        "--cosine_annealing_period_scaling",
+        type=int,
+        default=2,
+        help="how much to multiply each period in successive annealing",
+    )
+    parser.add_argument(
+        "--patience",
+        type=int,
+        default=5,
+        help="Number of epochs without improvement on dev before halving learning rate and reloading best model [default: 5]",
+    )
+    parser.add_argument(
+        "--num_adv_steps",
+        type=int,
+        default=1,
+        help="Number of steps for domain adaptation discriminator per one step of encoding model [default: 5]",
+    )
+
+    # -------------------------------------
+    # Callbacks
+    # -------------------------------------
+
+    parser.add_argument(
+        "--callback_names",
+        type=str,
+        action=set_protgps_type("callback"),
+        nargs="*",
+        default=["checkpointer", "lr_monitor"],
+        help="Lightning callbacks",
+    )
+
+    parser.add_argument(
+        "--monitor",
+        type=str,
+        default=None,
+        help="Name of metric to use to decide when to save model",
+    )
+
+    parser.add_argument(
+        "--checkpoint_save_top_k",
+        type=int,
+        default=1,
+        help="the best k models according to the quantity monitored will be saved",
+    )
+    parser.add_argument(
+        "--checkpoint_save_last",
+        action="store_true",
+        default=False,
+        help="save the last model to last.ckpt",
+    )
+
+    # -------------------------------------
+    # Model checkpointing
+    # -------------------------------------
+
+    parser.add_argument(
+        "--checkpoint_dir", type=str, default="snapshot", help="Where to dump the model"
+    )
+    parser.add_argument(
+        "--from_checkpoint",
+        action="store_true",
+        default=False,
+        help="Whether loading a model from a saved checkpoint",
+    )
+    parser.add_argument(
+        "--relax_checkpoint_matching",
+        action="store_true",
+        default=False,
+        help="Do not enforce that the keys in checkpoint_path match the keys returned by this module’s state dict",
+    )
+    parser.add_argument(
+        "--checkpoint_path",
+        type=str,
+        default=None,
+        help="Filename of model snapshot to load[default: None]",
+    )
+
+    # -------------------------------------
+    # Storing model outputs
+    # -------------------------------------
+    parser.add_argument(
+        "--save_hiddens",
+        action="store_true",
+        default=False,
+        help="Save hidden repr from each image to an npz based off results path, git hash and exam name",
+    )
+    parser.add_argument(
+        "--save_predictions",
+        action="store_true",
+        default=False,
+        help="Save hidden repr from each image to an npz based off results path, git hash and exam name",
+    )
+    parser.add_argument(
+        "--inference_dir",
+        type=str,
+        default="hiddens/test_run",
+        help='Dir to store hiddens npy"s when store_hiddens is true',
+    )
+
+    # -------------------------------------
+    # Run outputs
+    # -------------------------------------
+    parser.add_argument(
+        "--results_path",
+        type=str,
+        default="logs/test.args",
+        help="Where to save the result logs",
+    )
+    parser.add_argument(
+        "--experiment_name",
+        type=str,
+        help="defined either automatically by dispatcher.py or time in main.py. Keep without default",
+    )
+
+    # -------------------------------------
+    # System
+    # -------------------------------------
+    parser.add_argument(
+        "--num_workers",
+        type=int,
+        default=8,
+        help="Num workers for each data loader [default: 4]",
+    )
+
+    # cache
+    parser.add_argument(
+        "--cache_path", type=str, default=None, help="Dir to cache images."
+    )
+
+    # -------------------------------------
+    # Logging
+    # -------------------------------------
+
+    parser.add_argument(
+        "--logger_name",
+        type=str,
+        action=set_protgps_type("logger"),
+        choices=["tensorboard", "comet", "wandb"],
+        default="tensorboard",
+        help="experiment logger to use",
+    )
+    parser.add_argument(
+        "--logger_tags", nargs="*", default=[], help="List of tags for logger"
+    )
+    parser.add_argument("--project_name", default="CancerCures", help="Comet project")
+    parser.add_argument("--workspace", default="pgmikhael", help="Comet workspace")
+    parser.add_argument(
+        "--log_gen_image",
+        action="store_true",
+        default=False,
+        help="Whether to log sample generated image to comet",
+    )
+    parser.add_argument(
+        "--log_profiler",
+        action="store_true",
+        default=False,
+        help="Log profiler times to logger",
+    )
+
+    # -------------------------------------
+    # Add object-level args
+    # -------------------------------------
+
+    def add_class_args(args_as_dict, parser):
+        # for loop
+        for argname, argval in args_as_dict.items():
+            args_for_protgpss = {
+                a.dest: a for a in parser._actions if hasattr(a, "is_protgps_action")
+            }
+            old_args = vars(parser.parse_known_args()[0])
+            if argname in args_for_protgpss:
+                args_for_protgpss[argname].add_args(parser, argval)
+                newargs = vars(parser.parse_known_args()[0])
+                newargs = {k: v for k, v in newargs.items() if k not in old_args}
+                add_class_args(newargs, parser)
+
+    parser.parse_known_args(namespace=global_namespace)
+    add_class_args(vars(global_namespace), parser)
+
+    return parser
+
+
+def parse_args(args_strings=None):
+    # run
+    parser = Trainer.add_argparse_args(get_parser())
+    if args_strings is None:
+        args = parser.parse_args()
+    else:
+        args = parser.parse_args(args_strings)
+
+    # using gpus
+    if (isinstance(args.gpus, str) and len(args.gpus.split(",")) > 1) or (
+        isinstance(args.gpus, int) and args.gpus > 1
+    ):
+        args.strategy = "ddp"
+        args.replace_sampler_ddp = False
+    else:
+        args.strategy = None
+        args.replace_sampler_ddp = False
+
+    # username
+    args.unix_username = pwd.getpwuid(os.getuid())[0]
+
+    # learning initial state
+    args.step_indx = 1
+
+    # set args
+    args_for_protgpss = {a.dest: a for a in parser._actions if hasattr(a, "is_protgps_action")}
+    for argname, argval in vars(args).items():
+        if argname in args_for_protgpss:
+            args_for_protgpss[argname].set_args(args, argval)
+
+    # parse tune parameters
+    # args = parse_tune_params(args)
+
+    return args

data/protgps/utils/registry.py

@@ -0,0 +1,44 @@
+import hashlib
+
+REGISTRIES = {
+    "LIGHTNING_REGISTRY": {},
+    "DATASET_REGISTRY": {},
+    "MODEL_REGISTRY": {},
+    "LOSS_REGISTRY": {},
+    "METRIC_REGISTRY": {},
+    "OPTIMIZER_REGISTRY": {},
+    "SCHEDULER_REGISTRY": {},
+    "SEARCHER_REGISTRY": {},
+    "CALLBACK_REGISTRY": {},
+    "INPUT_LOADER_REGISTRY": {},
+    "AUGMENTATION_REGISTRY": {},
+    "LOGGER_REGISTRY": {},
+}
+
+
+def get_object(object_name, object_type):
+    if object_name not in REGISTRIES["{}_REGISTRY".format(object_type.upper())]:
+        raise Exception(
+            "INVALID {} NAME: {}. AVAILABLE {}".format(
+                object_type.upper(),
+                object_name,
+                REGISTRIES["{}_REGISTRY".format(object_type.upper())].keys(),
+            )
+        )
+    return REGISTRIES["{}_REGISTRY".format(object_type.upper())][object_name]
+
+
+def register_object(object_name, object_type):
+    def decorator(obj):
+        REGISTRIES["{}_REGISTRY".format(object_type.upper())][object_name] = obj
+        obj.name = object_name
+        return obj
+
+    return decorator
+
+
+def md5(key):
+    """
+    returns a hashed with md5 string of the key
+    """
+    return hashlib.md5(key.encode()).hexdigest()

data/protgps/utils/sampler.py

@@ -0,0 +1,100 @@
+import math
+from typing import TypeVar, Optional, Iterator, Sequence
+
+import torch
+from torch.utils.data import Dataset
+import torch.distributed as dist
+
+
+T_co = TypeVar('T_co', covariant=True)
+
+
+class DistributedWeightedSampler(torch.utils.data.distributed.DistributedSampler):
+    r"""Extension of pytorch's native distributed sampler, but supports weighted sampling
+    .. note::
+        Dataset is assumed to be of constant size.
+    Arguments:
+        dataset: Dataset used for sampling.
+        num_replicas (int, optional): Number of processes participating in
+            distributed training. By default, :attr:`rank` is retrieved from the
+            current distributed group.
+        rank (int, optional): Rank of the current process within :attr:`num_replicas`.
+            By default, :attr:`rank` is retrieved from the current distributed
+            group.
+            indices.
+        seed (int, optional): random seed used to shuffle the sampler if
+            :attr:`shuffle=True`. This number should be identical across all
+            processes in the distributed group. Default: ``0``.
+        drop_last (bool, optional): if ``True``, then the sampler will drop the
+            tail of the data to make it evenly divisible across the number of
+            replicas. If ``False``, the sampler will add extra indices to make
+            the data evenly divisible across the replicas. Default: ``False``.
+    .. warning::
+        In distributed mode, calling the :meth:`set_epoch` method at
+        the beginning of each epoch **before** creating the :class:`DataLoader` iterator
+        is necessary to make shuffling work properly across multiple epochs. Otherwise,
+        the same ordering will be always used.
+    Example::
+        >>> sampler = DistributedSampler(dataset) if is_distributed else None
+        >>> loader = DataLoader(dataset, shuffle=(sampler is None),
+        ...                     sampler=sampler)
+        >>> for epoch in range(start_epoch, n_epochs):
+        ...     if is_distributed:
+        ...         sampler.set_epoch(epoch)
+        ...     train(loader)
+    """
+
+    def __init__(self, dataset: Dataset, weights: Sequence[float],
+                 replacement: bool = True, generator=None, num_replicas: Optional[int] = None,
+                 rank: Optional[int] = None,
+                 seed: int = 0, drop_last: bool = False) -> None:
+        if num_replicas is None:
+            if not dist.is_available():
+                raise RuntimeError("Requires distributed package to be available")
+            num_replicas = dist.get_world_size()
+        if rank is None:
+            if not dist.is_available():
+                raise RuntimeError("Requires distributed package to be available")
+            rank = dist.get_rank()
+        self.dataset = dataset
+        self.num_replicas = num_replicas
+        self.rank = rank
+        self.epoch = 0
+        self.drop_last = drop_last
+        self.weights = torch.Tensor(weights)
+        self.replacement = replacement
+        self.generator = generator
+        # If the dataset length is evenly divisible by # of replicas, then there
+        # is no need to drop any data, since the dataset will be split equally.
+        if self.drop_last and len(self.dataset) % self.num_replicas != 0:
+            # Split to nearest available length that is evenly divisible.
+            # This is to ensure each rank receives the same amount of data when
+            # using this Sampler.
+            self.num_samples = math.ceil(
+                (len(self.dataset) - self.num_replicas) / self.num_replicas
+            )
+        else:
+            self.num_samples = math.ceil(len(self.dataset) / self.num_replicas)
+        self.total_size = self.num_samples * self.num_replicas
+        self.seed = seed
+
+    def __iter__(self) -> Iterator[T_co]:
+        indices = list(range(len(self.dataset)))
+
+        if not self.drop_last:
+            # add extra samples to make it evenly divisible
+            indices += indices[:(self.total_size - len(indices))]
+        else:
+            # remove tail of data to make it evenly divisible.
+            indices = indices[:self.total_size]
+        assert len(indices) == self.total_size
+
+        # subsample
+        indices = indices[self.rank:self.total_size:self.num_replicas]
+        weights = self.weights[self.rank:self.total_size:self.num_replicas]
+
+        assert len(indices) == self.num_samples
+
+        rand_tensor = torch.multinomial(self.weights, self.num_samples, self.replacement, generator=self.generator)
+        return iter(rand_tensor)
+

data/pyproject.toml

@@ -0,0 +1,25 @@
+[tool.poetry]
+name = "protgps"
+version = "0.0.1"
+description = ""
+authors = ["Peter G Mikhael <[email protected]>"]
+license = "MIT"
+readme = "README.md"
+repository = "https://github.com/pgmikhael/protgps"
+
+
+[tool.poetry.dependencies]
+python = "3.8"
+
+[tool.poetry.group.ci.dependencies]
+black      = "^23.3.0"
+mypy       = "^1.1.1"
+pylint     = "^2.13.0"
+pytest     = "^7.1.2"
+pytest-cov = "^3.0.0"
+rstcheck   = { version = "^6.1.2", python = "<4" }
+ruff       = "^0.0.291"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

data/scripts/dispatcher.py

@@ -0,0 +1,146 @@
+# append project root to system path
+import sys, os
+from os.path import dirname, realpath
+
+sys.path.append((dirname(dirname(realpath(__file__)))))
+import argparse
+import subprocess
+import multiprocessing
+import pickle
+import json
+import protgps.utils.parsing as parsing
+from protgps.utils.registry import md5
+
+EXPERIMENT_CRASH_MSG = "ALERT! job:[{}] has crashed! Check logfile at:[{}]"
+CONFIG_NOT_FOUND_MSG = "ALERT! {} config {} file does not exist!"
+SUCESSFUL_SEARCH_STR = "SUCCESS! Grid search results dumped to {}."
+
+parser = argparse.ArgumentParser(description="Dispatcher.")
+parser.add_argument(
+    "--config_path",
+    "-c",
+    type=str,
+    required=True,
+    default="configs/config_file.json",
+    help="path to model configurations json file",
+)
+parser.add_argument(
+    "--log_dir",
+    "-l",
+    type=str,
+    default="logs",
+    help="path to store logs and detailed job level result files",
+)
+parser.add_argument(
+    "--dry_run",
+    "-n",
+    action="store_true",
+    default=False,
+    help="print out commands without running",
+)
+parser.add_argument(
+    "--eval_train_config",
+    "-e",
+    action="store_true",
+    default=False,
+    help="create evaluation run from a training config",
+)
+
+
+def launch_experiment(script, gpu, flag_string):
+    """
+    Launch an experiment and direct logs and results to a unique filepath.
+
+    Args:
+        script (str): file name to run as main
+        gpu (str): gpu this worker can access.
+        flag_string (str): arguments and values as a single blob.
+
+    Returns:
+        results_path (str): path to saved args pickle file
+        log_path (str): path to logs
+    """
+    if not os.path.isdir(args.log_dir):
+        os.makedirs(args.log_dir)
+
+    log_name = md5(flag_string)
+    log_stem = os.path.join(args.log_dir, log_name)
+    log_path = "{}.txt".format(log_stem)
+    results_path = "{}.args".format(log_stem)
+
+    experiment_string = f"CUDA_VISIBLE_DEVICES={gpu} python -u scripts/{script}.py {flag_string} --results_path {log_stem} --experiment_name {log_name}"  # use log_stem instead of results_path, add extensions in main/learn.py
+
+    # forward logs to logfile
+    if "--resume" in flag_string:
+        pipe_str = ">>"
+    else:
+        pipe_str = ">"
+
+    shell_cmd = f"{experiment_string} {pipe_str} {log_path} 2>&1"
+    print("Launched exp: {}".format(shell_cmd))
+
+    if not os.path.exists(results_path) and (not args.dry_run):
+        subprocess.call(shell_cmd, shell=True)
+
+    return results_path, log_path
+
+
+def worker(script, gpu, job_queue, done_queue):
+    """
+    Worker thread for each gpu. Consumes all jobs and pushes results to done_queue.
+
+    Args:
+        script (str): file name to run as main
+        gpu (str): gpu this worker can access.
+        job_queue (Queue): queue of available jobs.
+        done_queue (Queue): queue where to push results.
+    """
+
+    while not job_queue.empty():
+        params = job_queue.get()
+        if params is None:
+            return
+        done_queue.put(launch_experiment(script, gpu, params))
+
+
+if __name__ == "__main__":
+
+    args = parser.parse_args()
+    if not os.path.exists(args.config_path):
+        print(CONFIG_NOT_FOUND_MSG.format("experiment", args.config_path))
+        sys.exit(1)
+    experiment_config = json.load(open(args.config_path, "r"))
+
+    if args.eval_train_config:
+        experiments, flags, experiment_axies = parsing.prepare_training_config_for_eval(
+            experiment_config
+        )
+    else:
+        experiments, flags, experiment_axies = parsing.parse_dispatcher_config(
+            experiment_config
+        )
+
+    job_queue = multiprocessing.Queue()
+    done_queue = multiprocessing.Queue()
+
+    for job in experiments:
+        job_queue.put(job)
+    print("Launching Dispatcher with {} jobs!".format(len(experiments)))
+    print()
+
+    for gpu in experiment_config["available_gpus"]:
+        print("Start gpu worker {}".format(gpu))
+        multiprocessing.Process(
+            target=worker,
+            args=(experiment_config["script"], gpu, job_queue, done_queue),
+        ).start()
+        print()
+
+    for i in range(len(experiments)):
+        result_path, log_path = done_queue.get()  # .rslt and .txt (stderr/out) files
+        try:
+            result_dict = pickle.load(open(result_path, "rb"))
+            dump_result_string = SUCESSFUL_SEARCH_STR.format(result_path)
+            print("({}/{}) \t {}".format(i + 1, len(experiments), dump_result_string))
+        except Exception:
+            print("Experiment failed! Logs are located at: {}".format(log_path))