Added initial app

.gitignore

@@ -0,0 +1,4 @@
+__pycache__
+log
+tmp
+output_predictions.csv

Dockerfile

@@ -0,0 +1,44 @@
+# Use NVIDIA PyTorch image as the base
+FROM nvcr.io/nvidia/pytorch:22.03-py3
+
+RUN apt-get update && apt-get install -y libxrender1
+
+# Base pytorch 
+RUN conda install pytorch==1.12.0 torchvision==0.13.0 torchaudio==0.12.0 cudatoolkit=11.6 -c pytorch -c conda-forge
+
+# Set required versions for each core dependency using cu116
+RUN pip install torch-scatter==2.0.9 torch-sparse==0.6.14 torch-cluster==1.6.0 torch-spline-conv==1.2.1 torch-geometric==2.1.0 -f https://data.pyg.org/whl/torch-1.12.0+cu116.html
+
+# Create a new user named "user" with UID 1000
+RUN useradd -m -u 1000 user
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1 \
+    GRADIO_ALLOW_FLAGGING=never \
+    GRADIO_NUM_PORTS=1 \
+    GRADIO_SERVER_NAME=0.0.0.0 \
+    GRADIO_THEME=huggingface \
+    SYSTEM=spaces \
+    HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Set the working directory to the user's app directory as root
+WORKDIR $HOME/app
+
+# Copy the current directory contents into the container at $HOME/app
+COPY . $HOME/app
+
+# Change ownership of the app directory to "user"
+RUN chown -R user:user $HOME/app
+
+# Switch to the "user" user
+USER user
+
+# Upgrade pip as the user
+RUN pip install --no-cache-dir --upgrade pip
+
+# Install the local package as the user
+RUN pip install --user .
+
+# Set the default command to bash
+CMD ["/bin/bash"]

README.md

@@ -1,11 +1,121 @@
----
-title: PLA Net
-emoji: 📈
-colorFrom: red
-colorTo: gray
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# PLA-Net: Predicting Protein-Ligand Interactions with Deep Graph Networks
+
+Forked version of [PLA-Net](https://github.com/BCV-Uniandes/PLA-Net) 
+
+## Background
+
+**PLA-Net** is a deep learning model designed to predict interactions between small organic molecules (ligands) and any of the 102 target proteins in the Alzheimer's Disease (AD) dataset. By transforming molecular and protein sequences into graph representations, PLA-Net leverages Graph Convolutional Networks (GCNs) to analyze and predict target-ligand interaction probabilities. Developed by [BCV-Uniandes](https://github.com/BCV-Uniandes/PLA-Net).
+
+## Key Features
+
+- **Graph-Based Input Representation**
+  - **Ligand Module (LM):** Converts SMILES sequences of molecules into graph representations.
+  - **Protein Module (PM):** Transforms FASTA sequences of proteins into graph structures.
+
+- **Deep Graph Convolutional Networks**
+  - Each module employs a deep GCN followed by an average pooling layer to extract meaningful features from the input graphs.
+
+- **Interaction Prediction**
+  - The feature representations from the LM and PM are concatenated.
+  - A fully connected layer processes the combined features to predict the interaction probability between the ligand and the target protein.
+
+## Quick Start
+
+If you want to run PLA-Net without installing it, you can run it freely on this [Hugging Face Space](https://huggingface.co/spaces/juliocesar-io/PLA-Net).
+
+## Docker Install
+
+To prevent conflicts with the host machine, it is recommended to run PLA-Net in a Docker container.
+
+First make sure you have an NVIDIA GPU and [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/install-guide.html) installed. Then build the image with the following command:
+
+```bash
+docker build -t pla-net:latest .
+```
+
+### Inference
+
+To run inference, run the following command:
+
+This will run inference for the target protein `ada` with the SMILES in the `input_smiles.csv` file and save the predictions to the `output_predictions.csv` file.
+
+The prediction file has the following format:
+
+```bash
+target,smiles,interaction_probability,interaction_class
+ada,Cn4c(CCC(=O)Nc3ccc2ccn(CC[C@H](CO)n1cnc(C(N)=O)c1)c2c3)nc5ccccc45,0.9994347542524338,1
+```
+
+Where `interaction_class` is 1 if the interaction probability is greater than 0.5, and 0 otherwise.
+
+```bash
+docker run \
+    -it --rm --gpus all \
+    -v "$(pwd)":/home/user/output \
+    pla-net:latest \
+    python /home/user/app/scripts/pla_net_inference.py \
+    --use_gpu \
+    --target ada \
+    --target_list /home/user/app/data/datasets/AD/Targets_Fasta.csv \
+    --target_checkpoint_path /home/user/app/pretrained-models/BINARY_ada \
+    --input_file_smiles /home/user/app/example/input_smiles.csv \
+    --output_file /home/user/output/output_predictions.csv
+```
+
+Args:
+
+- `use_gpu`: Use GPU for inference.
+- `target`: Target protein ID from the list of targets. Check the list of available targets in the [data](https://github.com/juliocesar-io/PLA-Net/blob/main/data/datasets/AD/Targets_Fasta.csv) folder.
+- `target_list`: Path to the target list CSV file.
+- `target_checkpoint_path`: Path to the target checkpoint. (e.g. `/workspace/pretrained-models/BINARY_ada`) one checkpoint for each target.
+- `input_file_smiles`: Path to the input SMILES file.
+- `output_file`: Path to the output predictions file.
+
+
+### Gradio Server
+We provide a simple graphical user interface to run PLA-Net with Gradio. To use it, run the following command:
+
+```bash
+docker run \
+    -it --rm --gpus all \
+    -p 7860:7860 \
+    pla-net:latest \
+    python app.py
+```
+
+Then open your browser and go to `http://localhost:7860/` to access the web interface. 
+
+    
+## Local Install
+
+To do inference with PLA-Net, you need to install the dependencies and activate the environment. You can do this by running the following commands:
+
+```bash
+conda env create -f environment.yml
+conda activate pla-net
+```
+
+Now you can run inference with PLA-Net locally. In the project folder, run the following command:
+
+```bash
+python scripts/pla_net_inference.py \
+    --use_gpu \
+    --target ada \
+    --target_list data/datasets/AD/Targets_Fasta.csv \
+    --target_checkpoint_path pretrained-models/BINARY_ada \
+    --input_file_smiles example/input_smiles.csv \
+    --output_file example/output_predictions.csv
+```
+
+## Models
+
+You can download the pre-trained models from [Hugging Face](https://huggingface.co/juliocesar-io/PLA-Net).
+## Training 
+
+To train each of the components of our method: LM, LM+Advs, LMPM and PLA-Net please refer to planet.sh file and run the desired models.
+
+To evaluate each of the components of our method: LM, LM+Advs, LMPM and PLA-Net please run the corresponding bash file in the inference folder.
+
+## Citation
+
+Ruiz Puentes, P., Rueda-Gensini, L., Valderrama, N. et al. Predicting target–ligand interactions with graph convolutional networks for interpretable pharmaceutical discovery. Sci Rep 12, 8434 (2022). https://doi.org/10.1038/s41598-022-12180-x

app.py

@@ -0,0 +1,154 @@
+import uuid
+import gradio as gr
+import torch
+import os
+import pandas as pd
+from rdkit import Chem
+from scripts.pla_net_inference import main
+from utils.args import ArgsInit
+
+os.system("nvidia-smi")
+print("TORCH_CUDA", torch.cuda.is_available())
+
+PROJECT_URL = "https://www.nature.com/articles/s41598-022-12180-x"
+
+DEFAULT_PATH_DOCKER = "/home/user/app"
+
+def load_and_filter_data(protein_id, ligand_smiles):
+    
+    # generate random short id, make short
+    random_id = str(uuid.uuid4())[:8]
+    
+    print("Inference ID: ", random_id)
+    
+    # check that ligand_smiles is not empty
+    if not ligand_smiles or ligand_smiles.strip() == "":
+        error_msg = f"!SMILES string is required"
+        raise gr.Error(error_msg, duration=5)
+    
+    # Split the input SMILES string by ':' to get a list
+    smiles_list = ligand_smiles.split(':')
+    
+    
+    
+    print("Smiles to predict: ", smiles_list)
+    print("Target Protein ID: ", protein_id)
+    
+    # Validate SMILES
+    invalid_smiles = []
+    for smiles in smiles_list:
+        mol = Chem.MolFromSmiles(smiles.strip())
+        if mol is None:
+            invalid_smiles.append(smiles.strip())
+            
+
+    
+    if invalid_smiles:
+        error_msg = f"!Invalid 💥 SMILES string(s) : {', '.join(invalid_smiles)}"
+        raise gr.Error(error_msg, duration=5)
+    
+        # Create tmp folder
+    os.makedirs(f"{DEFAULT_PATH_DOCKER}/example/tmp", exist_ok=True)
+    
+    # Save SMILES to CSV
+    df = pd.DataFrame({"smiles": [s.strip() for s in smiles_list if s.strip()]})
+    df.to_csv(f"{DEFAULT_PATH_DOCKER}/example/tmp/{random_id}_input_smiles.csv", index=False)
+    
+    # Run inference
+    args = ArgsInit().args
+    args.nclasses = 2
+    args.batch_size = 10
+    args.use_prot = True
+    args.freeze_molecule = True
+    args.conv_encode_edge = True
+    args.learn_t = True
+    args.binary = True
+    
+    args.use_gpu = True
+    args.target = protein_id
+    args.target_list = f"{DEFAULT_PATH_DOCKER}/data/datasets/AD/Targets_Fasta.csv"
+    args.target_checkpoint_path = f"{DEFAULT_PATH_DOCKER}/pretrained-models/BINARY_{protein_id}"
+    args.input_file_smiles = f"{DEFAULT_PATH_DOCKER}/example/tmp/{random_id}_input_smiles.csv"
+    args.output_file = f"{DEFAULT_PATH_DOCKER}/example/tmp/{random_id}_output_predictions.csv"
+    
+   
+    print("Args: ", args)
+    main(args)
+    
+    # Load the CSV file
+    df = pd.read_csv(f'{DEFAULT_PATH_DOCKER}/example/tmp/{random_id}_output_predictions.csv')
+    
+    print("Prediction Results output: ", df)
+    return df
+
+def load_description(fp):
+    with open(fp, 'r', encoding='utf-8') as f:
+        content = f.read()
+    return content
+
+def run_inference(protein_id, ligand_smile):
+    result_df = load_and_filter_data(protein_id, ligand_smile)
+    return result_df
+
+def create_interface():
+    with gr.Blocks(title="PLA-Net Web Inference") as inference:
+        gr.HTML(load_description("gradio/title.md"))
+
+        gr.Markdown("### Input")
+        with gr.Row():
+            with gr.Column():
+                gr.Markdown("#### Target Protein")
+                protein_id = gr.Dropdown(
+                    choices=["ada"],
+                    label="Target Protein ID",
+                    info="Select the target protein from the dropdown menu.",
+                    value="ada"
+                )
+            with gr.Column():
+                gr.Markdown("#### Ligand")
+                ligand_smile = gr.Textbox(
+                    info="Provide SMILES input (separate multiple SMILES with ':' )",
+                    placeholder="SMILES input",
+                    label="SMILES string(s)",
+                )
+                gr.Examples(
+                    examples=[
+                        "Cn4c(CCC(=O)Nc3ccc2ccn(CC[C@H](CO)n1cnc(C(N)=O)c1)c2c3)nc5ccccc45",
+                        "OCCCCCn1cnc2C(O)CN=CNc12",
+                        "Nc4nc(c1ccco1)c3ncn(C(=O)NCCc2ccccc2)c3n4"
+                    ],
+                    inputs=ligand_smile,
+                    label="Example SMILES"
+                )
+        btn = gr.Button("Run")
+        gr.Markdown("### Output")   
+        out = gr.Dataframe(
+            headers=["target", "smiles", "interaction_probability", "interaction_class"],
+            datatype=["str", "str", "number", "number"],
+            label="Prediction Results"
+        )
+        
+        btn.click(fn=run_inference, inputs=[protein_id, ligand_smile], outputs=out)
+        
+        gr.Markdown("""
+                    PLA-Net model for predicting interactions
+                    between small organic molecules and one of the 102 target proteins in the AD dataset. Graph representations
+                    of the molecule and a given target protein are generated from SMILES and FASTA sequences and are used as
+                    input to the Ligand Module (LM) and Protein Module (PM), respectively. Each module comprises a deep GCN
+                    followed by an average pooling layer, which extracts relevant features of their corresponding input graph. Both
+                    representations are finally concatenated and combined through a fully connected layer to predict the target–
+                    ligand interaction probability.
+                    """)
+        
+        gr.Markdown("""
+        Ruiz Puentes, P., Rueda-Gensini, L., Valderrama, N. et al. 
+        Predicting target–ligand interactions with graph convolutional networks 
+        for interpretable pharmaceutical discovery. Sci Rep 12, 8434 (2022). 
+        [https://doi.org/10.1038/s41598-022-12180-x](https://doi.org/10.1038/s41598-022-12180-x)
+        """)
+    
+    return inference
+
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch()

data/__init__.py

@@ -0,0 +1,4 @@
+import sys
+import os
+ROOT_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+sys.path.append(ROOT_DIR)

data/dataset.py

@@ -0,0 +1,418 @@
+import pandas as pd
+import shutil, os
+import os.path as osp
+import numpy as np
+from tqdm import tqdm
+
+import torch
+from torch_geometric.data import Data
+from torch.autograd import Variable
+
+from rdkit import Chem
+
+from data.features import (
+    allowable_features,
+    atom_to_feature_vector,
+    bond_to_feature_vector,
+    atom_feature_vector_to_dict,
+    bond_feature_vector_to_dict,
+)
+
+from utils.data_util import one_hot_vector_sm, one_hot_vector_am, get_atom_feature_dims
+
+
+def load_dataset(
+    cross_val, binary_task, target, args, use_prot=False, advs=False, test=False, inference=False, saliency=False
+):
+    """
+    Load data and return data in dataframes format for each split and the loader of each split.
+    Args:
+        cross_val (int): Data partition being used [1-4].
+        binary_tast (boolean): Whether to perform binary classification or multiclass classification.
+        target (string): Name of the protein target for binary classification.
+        args (parser): Complete arguments (configuration) of the model.
+        use_prot (boolean): Whether to use the PM module.
+        advs (boolean): Whether to train the LM module with adversarial augmentations.
+        test (boolean): Whether the model is being tested or trained.
+    Return:
+        train (loader): Training loader
+        valid (loader): Validation loader
+        test (loader): Test loader
+        data_train (dataframe): Training data dataframe
+        data_valid (dataframe): Validation data dataframe
+        data_test (dataframe): Test data dataframe
+
+    """
+    # Read all data files
+    if binary_task:
+        path = "data/datasets/AD/"
+        add_val = '_AD'
+    else:
+        path = "data/datasets/DUDE/"
+        add_val = ''
+    
+    data_test = pd.read_csv(
+        path + f"Smiles{add_val}_Test.csv", names=["Smiles", "Target", "Label"]
+    )
+
+    data_inference = pd.read_csv(
+        path + f"Inference.csv", names=["Smiles", "Target", "Label"]
+    )
+    if not test and not inference:
+        # Verify cross validation partition is defined
+        assert cross_val in [1, 2, 3, 4], "{} data partition is not defined".format(
+            cross_val
+        )
+        print("Loading data...")
+        
+        A = pd.read_csv(
+            path + f"Smiles{add_val}_1.csv", names=["Smiles", "Target", "Label"]
+        )
+        B = pd.read_csv(
+            path + f"Smiles{add_val}_2.csv", names=["Smiles", "Target", "Label"]
+        )
+        C = pd.read_csv(
+            path + f"Smiles{add_val}_3.csv", names=["Smiles", "Target", "Label"]
+        )
+        D = pd.read_csv(
+            path + f"Smiles{add_val}_4.csv", names=["Smiles", "Target", "Label"]
+        )
+        
+        if use_prot and binary_task:
+            data_target = pd.read_csv(
+                path + "Targets_Fasta.csv", names=["Fasta", "Target", "Label"]
+            )
+        else:
+            data_target = []
+            
+        # Generate train and validation splits according to cross validation number
+        if cross_val == 1:
+            data_train = pd.concat([A, B, C], ignore_index=True)
+            data_val = D
+        elif cross_val == 2:
+            data_train = pd.concat([A, C, D], ignore_index=True)
+            data_val = B
+        elif cross_val == 3:
+            data_train = pd.concat([A, B, D], ignore_index=True)
+            data_val = C
+        elif cross_val == 4:
+            data_train = pd.concat([B, C, D], ignore_index=True)
+            data_val = A
+            
+        # If in binary classification select data for the specific target being train
+        if binary_task:
+            data_train = data_train[data_train.Target == target]
+            data_val = data_val[data_val.Target == target]
+            data_test = data_test[data_test.Target == target]
+            if use_prot:
+                data_target = data_target[data_target.Target == target]
+                
+        # Get dataset for each split
+        train = get_dataset(data_train, use_prot, data_target, args, advs)
+        valid = get_dataset(data_val, use_prot, data_target, args)
+        test = get_dataset(data_test, use_prot, data_target, args)
+        
+    elif test and not inference:
+        # Read test data file
+        data_target = None
+        if binary_task:
+            data_test = data_test[data_test.Target == target]
+            if use_prot:
+                data_target = pd.read_csv(
+                    path + "Targets_Fasta.csv", names=["Fasta", "Target", "Label"]
+                )
+                data_target = data_target[data_target.Target == target]
+
+        test = get_dataset(
+                        data_test,
+                        target=data_target,
+                        use_prot=use_prot,
+                        args=args,
+                        advs=advs,
+                        saliency=saliency,
+                    )
+        # No need for these sets in test mode
+        train = []
+        valid = []
+        data_train = []
+        data_val = []
+
+    elif inference:
+        # Read inference data file
+        data_target = None
+        if binary_task:
+            data_inference = data_inference[data_inference.Target == target]
+            if use_prot:
+                data_target = pd.read_csv(
+                    path + "Targets_Fasta.csv", names=["Fasta", "Target", "Label"]
+                )
+                data_target = data_target[data_target.Target == target]
+
+        test = get_dataset(
+                        data_inference,
+                        target=data_target,
+                        use_prot=use_prot,
+                        args=args,
+                        advs=advs,
+                        saliency=args.saliency,
+                    )
+        # No need for these sets in test mode
+        train = []
+        valid = []
+        data_train = []
+        data_val = []
+
+    print("Done.")
+    return train, valid, test, data_train, data_val, data_test
+
+
+def reload_dataset(cross_val, binary_task, target, args, advs=False):
+    print("Reloading data")
+    args.edge_dict = {}
+    if binary_task:
+        path = "data/datasets/AD/"
+        A = pd.read_csv(path + "Smiles_AD_1.csv", names=["Smiles", "Target", "Label"])
+        B = pd.read_csv(path + "Smiles_AD_2.csv", names=["Smiles", "Target", "Label"])
+        C = pd.read_csv(path + "Smiles_AD_3.csv", names=["Smiles", "Target", "Label"])
+        D = pd.read_csv(path + "Smiles_AD_4.csv", names=["Smiles", "Target", "Label"])
+        data_test = pd.read_csv(
+            path + "AD_Test.csv", names=["Smiles", "Target", "Label"]
+        )
+
+    if cross_val == 1:
+        data_train = pd.concat([A, B, C], ignore_index=True)
+    elif cross_val == 2:
+        data_train = pd.concat([A, C, D], ignore_index=True)
+    elif cross_val == 3:
+        data_train = pd.concat([A, B, D], ignore_index=True)
+    else:
+        data_train = pd.concat([B, C, D], ignore_index=True)
+
+    if binary_task:
+        data_train = data_train[data_train.Target == target]
+
+    train = get_dataset(data_train, args=args, advs=advs)
+    print("Done.")
+
+    return train, data_train
+
+
+def smiles_to_graph(smiles_string, is_prot=False, received_mol=False):
+    """
+    Converts SMILES string to graph Data object
+    :input: SMILES string (str)
+    :return: graph object
+    """
+
+    if not is_prot:
+        mol = Chem.MolFromSmiles(smiles_string)
+    else:
+        mol = Chem.MolFromFASTA(smiles_string)
+    # atoms
+    atom_features_list = []
+    for atom in mol.GetAtoms():
+        ftrs = atom_to_feature_vector(atom)
+        atom_features_list.append(ftrs)
+
+    x = np.array(atom_features_list, dtype=np.int64)
+
+    # bonds
+    num_bond_features = 3  # bond type, bond stereo, is_conjugated
+    if len(mol.GetBonds()) > 0:  # mol has bonds
+        edges_list = []
+        edge_features_list = []
+        for bond in mol.GetBonds():
+            i = bond.GetBeginAtomIdx()
+            j = bond.GetEndAtomIdx()
+
+            edge_feature = bond_to_feature_vector(bond)
+
+            # add edges in both directions
+            edges_list.append((i, j))
+            edge_features_list.append(edge_feature)
+            edges_list.append((j, i))
+            edge_features_list.append(edge_feature)
+
+        # data.edge_index: Graph connectivity in COO format with shape [2, num_edges]
+        edge_index = np.array(edges_list, dtype=np.int64).T
+
+        # data.edge_attr: Edge feature matrix with shape [num_edges, num_edge_features]
+        edge_attr = np.array(edge_features_list, dtype=np.int64)
+
+    else:  # mol has no bonds
+        edge_index = np.empty((2, 0), dtype=np.int64)
+        edge_attr = np.empty((0, num_bond_features), dtype=np.int64)
+
+    return edge_attr, edge_index, x
+
+
+def smiles_to_graph_advs(
+    smiles_string, args, advs=False, received_mol=False, saliency=False
+):
+    """
+    Converts SMILES string to graph Data object
+    :input: SMILES string (str)
+    :return: graph object
+    """
+    if not received_mol:
+        mol = Chem.MolFromSmiles(smiles_string)
+    else:
+        mol = smiles_string
+
+    # atoms
+    atom_features_list = []
+    atom_feat_dims = get_atom_feature_dims()
+
+    for atom in mol.GetAtoms():
+        ftrs = atom_to_feature_vector(atom)
+        if saliency:
+            ftrs_oh = one_hot_vector_am(ftrs, atom_feat_dims)
+            atom_features_list.append(torch.unsqueeze(ftrs_oh, 0))
+        else:
+            atom_features_list.append(ftrs)
+
+    if saliency:
+        x = torch.cat(atom_features_list)
+    else:
+        x = np.array(atom_features_list, dtype=np.int64)
+
+    if advs:
+        # bonds
+        mol_edge_dict = {}
+
+    num_bond_features = 3  # bond type, bond stereo, is_conjugated
+    features_dim1 = torch.eye(5)
+    features_dim2 = torch.eye(6)
+    features_dim3 = torch.eye(2)
+    if len(mol.GetBonds()) > 0:  # mol has bonds
+        edges_list = []
+        edge_features_list = []
+        for bond in mol.GetBonds():
+            i = bond.GetBeginAtomIdx()
+            j = bond.GetEndAtomIdx()
+            edge_feature = bond_to_feature_vector(bond)
+
+            # add edges in both directions
+            edges_list.append((i, j))
+            edges_list.append((j, i))
+
+            edge_feature_oh = one_hot_vector_sm(
+                edge_feature, features_dim1, features_dim2, features_dim3
+            )
+            if advs:
+                mol_edge_dict[(i, j)] = Variable(
+                    torch.tensor([1.0]), requires_grad=True
+                )
+
+                # add edges in both directions
+                edge_features_list.append(
+                    torch.unsqueeze(mol_edge_dict[(i, j)] * edge_feature_oh, 0)
+                )
+                edge_features_list.append(
+                    torch.unsqueeze(mol_edge_dict[(i, j)] * edge_feature_oh, 0)
+                )
+            else:
+                # add edges in both directions
+                edge_features_list.append(torch.unsqueeze(edge_feature_oh, 0))
+                edge_features_list.append(torch.unsqueeze(edge_feature_oh, 0))
+        if advs:
+            # Update edge dict
+            args.edge_dict[smiles_string] = mol_edge_dict
+
+        # data.edge_index: Graph connectivity in COO format with shape [2, num_edges]
+        edge_index = np.array(edges_list, dtype=np.int64).T
+        # data.edge_attr: Edge feature matrix with shape [num_edges, num_edge_features]
+
+        edge_attr = torch.cat(edge_features_list)
+
+    else:  # mol has no bonds
+        edge_index = np.empty((2, 0), dtype=np.int64)
+        edge_attr = np.empty((0, num_bond_features), dtype=np.int64)
+        args.edge_dict[smiles_string] = {}
+
+    return edge_attr, edge_index, x
+
+
+def get_dataset(
+    dataset, use_prot=False, target=None, args=None, advs=False, saliency=False
+):
+    total_dataset = []
+    if use_prot:
+        prot_graph = transform_molecule_pg(
+            target["Fasta"].item(), label=None, is_prot=use_prot
+        )
+
+    for mol, label in tqdm(
+        zip(dataset["Smiles"], dataset["Label"]), total=len(dataset["Smiles"])
+    ):
+        if use_prot:
+            total_dataset.append(
+                [
+                    transform_molecule_pg(mol, label, args, advs, saliency=saliency),
+                    prot_graph,
+                ]
+            )
+        else:
+            total_dataset.append(
+                transform_molecule_pg(mol, label, args, advs, saliency=saliency)
+            )
+    return total_dataset
+
+
+def get_perturbed_dataset(mols, labels, args, valence=False):
+    total_dataset = []
+    for mol, label in zip(mols, labels):
+        total_dataset.append(transform_molecule_pg(mol, label, args, received_mol=True))
+    return total_dataset
+
+
+def transform_molecule_pg(
+    smiles,
+    label,
+    args=None,
+    advs=False,
+    received_mol=False,
+    saliency=False,
+    is_prot=False,
+):
+
+    if is_prot:
+        edge_attr_p, edge_index_p, x_p = smiles_to_graph(smiles, is_prot)
+        x_p = torch.tensor(x_p)
+        edge_index_p = torch.tensor(edge_index_p)
+        edge_attr_p = torch.tensor(edge_attr_p)
+
+        return Data(edge_attr=edge_attr_p, edge_index=edge_index_p, x=x_p)
+
+    else:
+        if args.advs or received_mol:
+            if advs or received_mol:
+                edge_attr, edge_index, x = smiles_to_graph_advs(
+                    smiles,
+                    args,
+                    advs=True,
+                    received_mol=received_mol,
+                    saliency=saliency,
+                )
+            else:
+                edge_attr, edge_index, x = smiles_to_graph_advs(
+                    smiles, args, received_mol=received_mol, saliency=saliency
+                )
+        else:
+            edge_attr, edge_index, x = smiles_to_graph(smiles)
+
+        if not saliency:
+            x = torch.tensor(x)
+        y = torch.tensor([label])
+        edge_index = torch.tensor(edge_index)
+        if not args.advs and not received_mol:
+            edge_attr = torch.tensor(edge_attr)
+
+        if received_mol:
+            mol = smiles
+        else:
+            mol = Chem.MolFromSmiles(smiles)
+
+        return Data(
+            edge_attr=edge_attr, edge_index=edge_index, x=x, y=y, mol=mol, smiles=smiles
+        )

data/dataset_saliency.py

@@ -0,0 +1,378 @@
+
+import pandas as pd
+import shutil, os
+import os.path as osp
+import numpy as np
+from tqdm import tqdm
+
+import torch
+from torch_geometric.data import Data
+from torch.autograd import Variable
+
+from rdkit import Chem
+
+from data.features import (
+    allowable_features,
+    atom_to_feature_vector,
+    bond_to_feature_vector,
+    atom_feature_vector_to_dict,
+    bond_feature_vector_to_dict,
+)
+
+from utils.data_util import one_hot_vector_sm, one_hot_vector_am, get_atom_feature_dims
+
+
+def load_dataset(
+    cross_val, binary_task, target, args, use_prot=False, advs=False, test=False
+):
+    """
+    Load data and return data in dataframes format for each split and the loader of each split.
+    Args:
+        cross_val (int): Data partition being used [1-4].
+        binary_tast (boolean): Whether to perform binary classification or multiclass classification.
+        target (string): Name of the protein target for binary classification.
+        args (parser): Complete arguments (configuration) of the model.
+        use_prot (boolean): Whether to use the PM module.
+        advs (boolean): Whether to train the LM module with adversarial augmentations.
+        test (boolean): Whether the model is being tested or trained.
+    Return:
+        train (loader): Training loader
+        valid (loader): Validation loader
+        test (loader): Test loader
+        data_train (dataframe): Training data dataframe
+        data_valid (dataframe): Validation data dataframe
+        data_test (dataframe): Test data dataframe
+
+    """
+    # TODO: NO QUEREMOS QUE ESTÉ LA PARTICIÓN DEL MULTICLASE?
+    # Read all data files
+    if not test:
+        # Verify cross validation partition is defined
+        assert cross_val in [1, 2, 3, 4], "{} data partition is not defined".format(
+            cross_val
+        )
+        print("Loading data...")
+        if binary_task:
+            path = "data/datasets/AD/"
+            A = pd.read_csv(
+                path + "Smiles_AD_1.csv", names=["Smiles", "Target", "Label"]
+            )
+            B = pd.read_csv(
+                path + "Smiles_AD_2.csv", names=["Smiles", "Target", "Label"]
+            )
+            C = pd.read_csv(
+                path + "Smiles_AD_3.csv", names=["Smiles", "Target", "Label"]
+            )
+            D = pd.read_csv(
+                path + "Smiles_AD_4.csv", names=["Smiles", "Target", "Label"]
+            )
+            data_test = pd.read_csv(
+                path + "AD_Test.csv", names=["Smiles", "Target", "Label"]
+            )
+            if use_prot:
+                data_target = pd.read_csv(
+                    path + "Targets_Fasta.csv", names=["Fasta", "Target", "Label"]
+                )
+            else:
+                data_target = []
+        # Generate train and validation splits according to cross validation number
+        if cross_val == 1:
+            data_train = pd.concat([A, B, C], ignore_index=True)
+            data_val = D
+        elif cross_val == 2:
+            data_train = pd.concat([A, C, D], ignore_index=True)
+            data_val = B
+        elif cross_val == 3:
+            data_train = pd.concat([A, B, D], ignore_index=True)
+            data_val = C
+        elif cross_val == 4:
+            data_train = pd.concat([B, C, D], ignore_index=True)
+            data_val = A
+        # If in binary classification select data for the specific target being train
+        if binary_task:
+            data_train = data_train[data_train.Target == target]
+            data_val = data_val[data_val.Target == target]
+            data_test = data_test[data_test.Target == target]
+            if use_prot:
+                data_target = data_target[data_target.Target == target]
+        # Get dataset for each split
+        train = get_dataset(data_train, use_prot, data_target, args, advs)
+        valid = get_dataset(data_val, use_prot, data_target, args)
+        test = get_dataset(data_test, use_prot, data_target, args)
+    else:
+        # Read test data file
+        if binary_task:
+            path = "data/datasets/AD/"
+            data_test = pd.read_csv(
+                path + "Smiles_AD_Test.csv", names=["Smiles", "Target", "Label"]
+            )
+            data_test = data_test[data_test.Target == target]
+            if use_prot:
+                data_target = pd.read_csv(
+                    path + "Targets_Fasta.csv", names=["Fasta", "Target", "Label"]
+                )
+                data_target = data_target[data_target.Target == target]
+            else:
+                data_target = []
+        test = get_dataset(data_test,target=data_target, use_prot=use_prot, args=args, advs=advs, saliency=args.saliency)
+        train = []
+        valid = []
+        data_train = []
+        data_val = []
+    print("Done.")
+    return train, valid, test, data_train, data_val, data_test
+
+
+def reload_dataset(cross_val, binary_task, target, args, advs=False):
+    print("Reloading data")
+    args.edge_dict = {}
+    if binary_task:
+        path = "data/datasets/AD/"
+        A = pd.read_csv(path + "Smiles_AD_1.csv", names=["Smiles", "Target", "Label"])
+        B = pd.read_csv(path + "Smiles_AD_2.csv", names=["Smiles", "Target", "Label"])
+        C = pd.read_csv(path + "Smiles_AD_3.csv", names=["Smiles", "Target", "Label"])
+        D = pd.read_csv(path + "Smiles_AD_4.csv", names=["Smiles", "Target", "Label"])
+        data_test = pd.read_csv(
+            path + "AD_Test.csv", names=["Smiles", "Target", "Label"]
+        )
+
+    if cross_val == 1:
+        data_train = pd.concat([A, B, C], ignore_index=True)
+    elif cross_val == 2:
+        data_train = pd.concat([A, C, D], ignore_index=True)
+    elif cross_val == 3:
+        data_train = pd.concat([A, B, D], ignore_index=True)
+    else:
+        data_train = pd.concat([B, C, D], ignore_index=True)
+
+    if binary_task:
+        data_train = data_train[data_train.Target == target]
+
+    train = get_dataset(data_train, args=args, advs=advs)
+    print("Done.")
+
+    return train, data_train
+
+
+def smiles_to_graph(smiles_string, is_prot=False, received_mol=False, saliency=False):
+    """
+    Converts SMILES string to graph Data object
+    :input: SMILES string (str)
+    :return: graph object
+    """
+
+    if not is_prot:
+        mol = Chem.MolFromSmiles(smiles_string)
+    else:
+        mol = Chem.MolFromFASTA(smiles_string)
+    # atoms
+    atom_features_list = []
+    atom_feat_dims = get_atom_feature_dims()
+    for atom in mol.GetAtoms():
+        ftrs = atom_to_feature_vector(atom)
+        if saliency:
+            ftrs_oh = one_hot_vector_am(ftrs, atom_feat_dims)
+            atom_features_list.append(torch.unsqueeze(ftrs_oh, 0))
+        else:
+            atom_features_list.append(ftrs)
+
+    if saliency:
+        x = torch.cat(atom_features_list)
+    else:
+        x = np.array(atom_features_list, dtype=np.int64)
+
+    # bonds
+    num_bond_features = 3  # bond type, bond stereo, is_conjugated
+    if len(mol.GetBonds()) > 0:  # mol has bonds
+        edges_list = []
+        edge_features_list = []
+        for bond in mol.GetBonds():
+            i = bond.GetBeginAtomIdx()
+            j = bond.GetEndAtomIdx()
+
+            edge_feature = bond_to_feature_vector(bond)
+
+            # add edges in both directions
+            edges_list.append((i, j))
+            edge_features_list.append(edge_feature)
+            edges_list.append((j, i))
+            edge_features_list.append(edge_feature)
+
+        # data.edge_index: Graph connectivity in COO format with shape [2, num_edges]
+        edge_index = np.array(edges_list, dtype=np.int64).T
+
+        # data.edge_attr: Edge feature matrix with shape [num_edges, num_edge_features]
+        edge_attr = np.array(edge_features_list, dtype=np.int64)
+
+    else:  # mol has no bonds
+        edge_index = np.empty((2, 0), dtype=np.int64)
+        edge_attr = np.empty((0, num_bond_features), dtype=np.int64)
+
+    return edge_attr, edge_index, x
+
+
+def smiles_to_graph_advs(
+    smiles_string, args, advs=False, received_mol=False, saliency=False
+):
+    """
+    Converts SMILES string to graph Data object
+    :input: SMILES string (str)
+    :return: graph object
+    """
+    if not received_mol:
+        mol = Chem.MolFromSmiles(smiles_string)
+    else:
+        mol = smiles_string
+
+    # atoms
+    atom_features_list = []
+    atom_feat_dims = get_atom_feature_dims()
+
+    for atom in mol.GetAtoms():
+        ftrs = atom_to_feature_vector(atom)
+        if saliency:
+            ftrs_oh = one_hot_vector_am(ftrs, atom_feat_dims)
+            atom_features_list.append(torch.unsqueeze(ftrs_oh, 0))
+        else:
+            atom_features_list.append(ftrs)
+
+    if saliency:
+        x = torch.cat(atom_features_list)
+    else:
+        x = np.array(atom_features_list, dtype=np.int64)
+
+    if advs:
+        # bonds
+        mol_edge_dict = {}
+
+    num_bond_features = 3  # bond type, bond stereo, is_conjugated
+    features_dim1 = torch.eye(5)
+    features_dim2 = torch.eye(6)
+    features_dim3 = torch.eye(2)
+    if len(mol.GetBonds()) > 0:  # mol has bonds
+        edges_list = []
+        edge_features_list = []
+        for bond in mol.GetBonds():
+            i = bond.GetBeginAtomIdx()
+            j = bond.GetEndAtomIdx()
+            edge_feature = bond_to_feature_vector(bond)
+
+            # add edges in both directions
+            edges_list.append((i, j))
+            edges_list.append((j, i))
+
+            edge_feature_oh = one_hot_vector_sm(
+                edge_feature, features_dim1, features_dim2, features_dim3
+            )
+            if advs:
+                mol_edge_dict[(i, j)] = Variable(
+                    torch.tensor([1.0]), requires_grad=True
+                )
+
+                # add edges in both directions
+                edge_features_list.append(
+                    torch.unsqueeze(mol_edge_dict[(i, j)] * edge_feature_oh, 0)
+                )
+                edge_features_list.append(
+                    torch.unsqueeze(mol_edge_dict[(i, j)] * edge_feature_oh, 0)
+                )
+            else:
+                # add edges in both directions
+                edge_features_list.append(torch.unsqueeze(edge_feature_oh, 0))
+                edge_features_list.append(torch.unsqueeze(edge_feature_oh, 0))
+        if advs:
+            # Update edge dict
+            args.edge_dict[smiles_string] = mol_edge_dict
+
+        # data.edge_index: Graph connectivity in COO format with shape [2, num_edges]
+        edge_index = np.array(edges_list, dtype=np.int64).T
+        # data.edge_attr: Edge feature matrix with shape [num_edges, num_edge_features]
+
+        edge_attr = torch.cat(edge_features_list)
+
+    else:  # mol has no bonds
+        edge_index = np.empty((2, 0), dtype=np.int64)
+        edge_attr = np.empty((0, num_bond_features), dtype=np.int64)
+        args.edge_dict[smiles_string] = {}
+
+    return edge_attr, edge_index, x
+
+
+def get_dataset(
+    dataset, use_prot=False, target=None, args=None, advs=False, saliency=False
+):
+    total_dataset = []
+    if use_prot:
+        prot_graph = transform_molecule_pg(
+            target["Fasta"].item(), label=None, is_prot=use_prot
+        )
+
+    for mol, label in tqdm(
+        zip(dataset["Smiles"], dataset["Label"]), total=len(dataset["Smiles"])
+    ):
+        if use_prot:
+            total_dataset.append([transform_molecule_pg(mol,label,args, advs, saliency=saliency),prot_graph])
+        else:
+            total_dataset.append(
+                transform_molecule_pg(mol, label, args, advs, saliency=saliency)
+            )
+    return total_dataset
+
+
+def get_perturbed_dataset(mols, labels, args):
+    total_dataset = []
+    for mol, label in zip(mols, labels):
+        total_dataset.append(transform_molecule_pg(mol, label, args, received_mol=True))
+    return total_dataset
+
+
+def transform_molecule_pg(
+    smiles,
+    label,
+    args=None,
+    advs=False,
+    received_mol=False,
+    saliency=False,
+    is_prot=False,
+):
+
+    if is_prot:
+        edge_attr_p, edge_index_p, x_p = smiles_to_graph(smiles, is_prot)
+        x_p = torch.tensor(x_p)
+        edge_index_p = torch.tensor(edge_index_p)
+        edge_attr_p = torch.tensor(edge_attr_p)
+
+        return Data(edge_attr=edge_attr_p, edge_index=edge_index_p, x=x_p)
+
+    else:
+        if args.advs or received_mol:
+            if advs or received_mol:
+                edge_attr, edge_index, x = smiles_to_graph_advs(
+                    smiles,
+                    args,
+                    advs=True,
+                    received_mol=received_mol,
+                    saliency=saliency,
+                )
+            else:
+                edge_attr, edge_index, x = smiles_to_graph_advs(
+                    smiles, args, received_mol=received_mol, saliency=saliency
+                )
+        else:
+            edge_attr, edge_index, x = smiles_to_graph(smiles, saliency=saliency)
+
+        if not saliency:
+            x = torch.tensor(x)
+        y = torch.tensor([label])
+        edge_index = torch.tensor(edge_index)
+        if not args.advs and not received_mol:
+            edge_attr = torch.tensor(edge_attr)
+
+        if received_mol:
+            mol = smiles
+        else:
+            mol = Chem.MolFromSmiles(smiles)
+
+        return Data(
+            edge_attr=edge_attr, edge_index=edge_index, x=x, y=y, mol=mol, smiles=smiles
+        )

data/datasets/AD/Inference.csv

@@ -0,0 +1 @@
+OCCCCCn1cnc2C(O)CN=CNc12,ada,0

data/datasets/AD/Targets_Fasta.csv

@@ -0,0 +1,102 @@
+MSDVAIVKEGWLHKRGEYIKTWRPRYFLLKNDGTFIGYKERPQDVDQREAPLNNFSVAQCQLMKTERPRPNTFIIRCLQWTTVIERTFHVETPEEREEWTTAIQTVADGLKKQEEEEMDFRSGSPSDNSGAEEMEVSLAKPKHRVTMNEFEYLKLLGKGTFGKVILVKEKATGRYYAMKILKKEVIVAKDEVAHTLTENRVLQNSRHPFLTALKYSFQTHDRLCFVMEYANGGELFFHLSRERVFSEDRARFYGAEIVSALDYLHSEKNVVYRDLKLENLMLDKDGHIKITDFGLCKEGIKDGATMKTFCGTPEYLAPEVLEDNDYGRAVDWWGLGVVMYEMMCGRLPFYNQDHEKLFELILMEEIRFPRTLGPEAKSLLSGLLKKDPKQRLGGGSEDAKEIMQHRFFAGIVWQHVYEKKLSPPFKPQVTSETDTRYFDEEFTAQMITITPPDQDDSMECVDSERRPHFPQFSYSASGTA,akt1,0
+MLSNSQGQSPPVPFPAPAPPPQPPTPALPHPPAQPPPPPPQQFPQFHVKSGLQIKKNAIIDDYKVTSQVLGLGINGKVLQIFNKRTQEKFALKMLQDCPKARREVELHWRASQCPHIVRIVDVYENLYAGRKCLLIVMECLDGGELFSRIQDRGDQAFTEREASEIMKSIGEAIQYLHSINIAHRDVKPENLLYTSKRPNAILKLTDFGFAKETTSHNSLTTPCYTPYYVAPEVLGPEKYDKSCDMWSLGVIMYILLCGYPPFYSNHGLAISPGMKTRIRMGQYEFPNPEWSEVSEEVKMLIRNLLKTEPTQRMTITEFMNHPWIMQSTKVPQTPLHTSRVLKEDKERWEDVKEEMTSALATMRVDYEQIKIKKIEDASNPLLLKRRKKARALEAAALAH,mapk2,1
+MAHVRGLQLPGCLALAALCSLVHSQHVFLAPQQARSLLQRVRRANTFLEEVRKGNLERECVEETCSYEEAFEALESSTATDVFWAKYTACETARTPRDKLAACLEGNCAEGLGTNYRGHVNITRSGIECQLWRSRYPHKPEINSTTHPGADLQENFCRNPDSSTTGPWCYTTDPTVRRQECSIPVCGQDQVTVAMTPRSEGSSVNLSPPLEQCVPDRGQQYQGRLAVTTHGLPCLAWASAQAKALSKHQDFNSAVQLVENFCRNPDGDEEGVWCYVAGKPGDFGYCDLNYCEEAVEEETGDGLDEDSDRAIEGRTATSEYQTFFNPRTFGSGEADCGLRPLFEKKSLEDKTERELLESYIDGRIVEGSDAEIGMSPWQVMLFRKSPQELLCGASLISDRWVLTAAHCLLYPPWDKNFTENDLLVRIGKHSRTRYERNIEKISMLEKIYIHPRYNWRENLDRDIALMKLKKPVAFSDYIHPVCLPDRETAASLLQAGYKGRVTGWGNLKETWTANVGKGQPSVLQVVNLPIVERPVCKDSTRIRITDNMFCAGYKPDEGKRGDACEGDSGGPFVMKSPFNNRWYQMGIVSWGEGCDRDGKYGFYTHVFRLKKWIQKVIDQFGE,thrb,2
+MWSWKCLLFWAVLVTATLCTARPSPTLPEQAQPWGAPVEVESFLVHPGDLLQLRCRLRDDVQSINWLRDGVQLAESNRTRITGEEVEVQDSVPADSGLYACVTSSPSGSDTTYFSVNVSDALPSSEDDDDDDDSSSEEKETDNTKPNRMPVAPYWTSPEKMEKKLHAVPAAKTVKFKCPSSGTPNPTLRWLKNGKEFKPDHRIGGYKVRYATWSIIMDSVVPSDKGNYTCIVENEYGSINHTYQLDVVERSPHRPILQAGLPANKTVALGSNVEFMCKVYSDPQPHIQWLKHIEVNGSKIGPDNLPYVQILKTAGVNTTDKEMEVLHLRNVSFEDAGEYTCLAGNSIGLSHHSAWLTVLEALEERPAVMTSPLYLEIIIYCTGAFLISCMVGSVIVYKMKSGTKKSDFHSQMAVHKLAKSIPLRRQVTVSADSSASMNSGVLLVRPSRLSSSGTPMLAGVSEYELPEDPRWELPRDRLVLGKPLGEGCFGQVVLAEAIGLDKDKPNRVTKVAVKMLKSDATEKDLSDLISEMEMMKMIGKHKNIINLLGACTQDGPLYVIVEYASKGNLREYLQARRPPGLEYCYNPSHNPEEQLSSKDLVSCAYQVARGMEYLASKKCIHRDLAARNVLVTEDNVMKIADFGLARDIHHIDYYKKTTNGRLPVKWMAPEALFDRIYTHQSDVWSFGVLLWEIFTLGGSPYPGVPVEELFKLLKEGHRMDKPSNCTNELYMMMRDCWHAVPSQRPTFKQLVEDLDRIVALTSNQEYLDLSMPLDQYSPSFPDTRSSTCSSGEDSVFSHEPLPEEPCLPRHPAQLANGGLKRR,fgfr1,3
+MRALLARLLLCVLVVSDSKGSNELHQVPSNCDCLNGGTCVSNKYFSNIHWCNCPKKFGGQHCEIDKSKTCYEGNGHFYRGKASTDTMGRPCLPWNSATVLQQTYHAHRSDALQLGLGKHNYCRNPDNRRRPWCYVQVGLKPLVQECMVHDCADGKKPSSPPEELKFQCGQKTLRPRFKIIGGEFTTIENQPWFAAIYRRHRGGSVTYVCGGSLISPCWVISATHCFIDYPKKEDYIVYLGRSRLNSNTQGEMKFEVENLILHKDYSADTLAHHNDIALLKIRSKEGRCAQPSRTIQTICLPSMYNDPQFGTSCEITGFGKENSTDYLYPEQLKMTVVKLISHRECQQPHYYGSEVTTKMLCAADPQWKTDSCQGDSGGPLVCSLQGRMTLTGIVSWGRGCALKDKPGVYTRVSHFLPWIRSHTKEENGLAL,urok,4
+MGMACLTMTEMEGTSTSSIYQNGDISGNANSMKQIDPVLQVYLYHSLGKSEADYLTFPSGEYVAEEICIAASKACGITPVYHNMFALMSETERIWYPPNHVFHIDESTRHNVLYRIRFYFPRWYCSGSNRAYRHGISRGAEAPLLDDFVMSYLFAQWRHDFVHGWIKVPVTHETQEECLGMAVLDMMRIAKENDQTPLAIYNSISYKTFLPKCIRAKIQDYHILTRKRIRYRFRRFIQQFSQCKATARNLKLKYLINLETLQSAFYTEKFEVKEPGSGPSGEEIFATIIITGNGGIQWSRGKHKESETLTEQDLQLYCDFPNIIDVSIKQANQEGSNESRVVTIHKQDGKNLEIELSSLREALSFVSLIDGYYRLTADAHHYLCKEVAPPAVLENIQSNCHGPISMDFAISKLKKAGNQTGLYVLRCSPKDFNKYFLTFAVERENVIEYKHCLITKNENEEYNLSGTKKNFSSLKDLLNCYQMETVRSDNIIFQFTKCCPPKPKDKSNLLVFRTNGVSDVPTSPTLQRPTHMNQMVFHKIRNEDLIFNESLGQGTFTKIFKGVRREVGDYGQLHETEVLLKVLDKAHRNYSESFFEAASMMSKLSHKHLVLNYGVCVCGDENILVQEFVKFGSLDTYLKKNKNCINILWKLEVAKQLAWAMHFLEENTLIHGNVCAKNILLIREEDRKTGNPPFIKLSDPGISITVLPKDILQERIPWVPPECIENPKNLNLATDKWSFGTTLWEICSGGDKPLSALDSQRKLQFYEDRHQLPAPKWAELANLINNCMDYEPDFRPSFRAIIRDLNSLFTPDYELLTENDMLPNMRIGALGFSGAFEDRDPTQFEERHLKFLQQLGKGNFGSVEMCRYDPLQDNTGEVVAVKKLQHSTEEHLRDFEREIEILKSLQHDNIVKYKGVCYSAGRRNLKLIMEYLPYGSLRDYLQKHKERIDHIKLLQYTSQICKGMEYLGTKRYIHRDLATRNILVENENRVKIGDFGLTKVLPQDKEYYKVKEPGESPIFWYAPESLTESKFSVASDVWSFGVVLYELFTYIEKSKSPPAEFMRMIGNDKQGQMIVFHLIELLKNNGRLPRPDGCPDEIYMIMTECWNNNVNQRPSFRDLALRVDQIRDNMAG,jak2,5
+MKTLLLLAVIMIFGLLQAHGNLVNFHRMIKLTTGKEAALSYGFYGCHCGVGGRGSPKDATDRCCVTHDCCYKRLEKRGCGTKFLSYKFSNSGSRITCAKQDSCRSQLCECDKAAATCFARNKTTYNKKYQYYSNKHCRGSTPRC,pa2ga,6
+MRQSLLFLTSVVPFVLAPRPPDDPGFGPHQRLEKLDSLLSDYDILSLSNIQQHSVRKRDLQTSTHVETLLTFSALKRHFKLYLTSSTERFSQNFKVVVVDGKNESEYTVKWQDFFTGHVVGEPDSRVLAHIRDDDVIIRINTDGAEYNIEPLWRFVNDTKDKRMLVYKSEDIKNVSRLQSPKVCGYLKVDNEELLPKGLVDREPPEELVHRVKRRADPDPMKNTCKLLVVADHRFYRYMGRGEESTTTNYLIELIDRVDDIYRNTSWDNAGFKGYGIQIEQIRILKSPQEVKPGEKHYNMAKSYPNEEKDAWDVKMLLEQFSFDIAEEASKVCLAHLFTYQDFDMGTLGLAYVGSPRANSHGGVCPKAYYSPVGKKNIYLNSGLTSTKNYGKTILTKEADLVTTHELGHNFGAEHDPDGLAECAPNEDQGGKYVMYPIAVSGDHENNKMFSNCSKQSIYKTIESKAQECFQERSNKVCGNSRVDEGEECDPGIMYLNNDTCCNSDCTLKEGVQCSDRNSPCCKNCQFETAQKKCQEAINATCKGVSYCTGNSSECPPPGNAEDDTVCLDLGKCKDGKCIPFCEREQQLESCACNETDNSCKVCCRDLSGRCVPYVDAEQKNLFLRKGKPCTVGFCDMNGKCEKRVQDVIERFWDFIDQLSINTFGKFLADNIVGSVLVFSLIFWIPFSILVHCVDKKLDKQYESLSLFHPSNVEMLSSMDSASVRIIKPFPAPQTPGRLQPAPVIPSAPAAPKLDHQRMDTIQEDPSTDSHMDEDGFEKDPFPNSSTAAKSFEDLTDHPVTRSEKAASFKLQRQNRVDSKETEC,ada17,7
+MEVQLGLGRVYPRPPSKTYRGAFQNLFQSVREVIQNPGPRHPEAASAAPPGASLLLLQQQQQQQQQQQQQQQQQQQQQQQETSPRQQQQQQGEDGSPQAHRRGPTGYLVLDEEQQPSQPQSALECHPERGCVPEPGAAVAASKGLPQQLPAPPDEDDSAAPSTLSLLGPTFPGLSSCSADLKDILSEASTMQLLQQQQQEAVSEGSSSGRAREASGAPTSSKDNYLGGTSTISDNAKELCKAVSVSMGLGVEALEHLSPGEQLRGDCMYAPLLGVPPAVRPTPCAPLAECKGSLLDDSAGKSTEDTAEYSPFKGGYTKGLEGESLGCSGSAAAGSSGTLELPSTLSLYKSGALDEAAAYQSRDYYNFPLALAGPPPPPPPPHPHARIKLENPLDYGSAWAAAAAQCRYGDLASLHGAGAAGPGSGSPSAAASSSWHTLFTAEEGQLYGPCGGGGGGGGGGGGGGGGGGGGGGGEAGAVAPYGYTRPPQGLAGQESDFTAPDVWYPGGMVSRVPYPSPTCVKSEMGPWMDSYSGPYGDMRLETARDHVLPIDYYFPPQKTCLICGDEASGCHYGALTCGSCKVFFKRAAEGKQKYLCASRNDCTIDKFRRKNCPSCRLRKCYEAGMTLGARKLKKLGNLKLQEEGEASSTTSPTEETTQKLTVSHIEGYECQPIFLNVLEAIEPGVVCAGHDNNQPDSFAALLSSLNELGERQLVHVVKWAKALPGFRNLHVDDQMAVIQYSWMGLMVFAMGWRSFTNVNSRMLYFAPDLVFNEYRMHKSRMYSQCVRMRHLSQEFGWLQITPQEFLCMKALLLFSIIPVDGLKNQKFFDELRMNYIKELDRIIACKRKNPTSCSRRFYQLTKLLDSVQPIARELHQFTFDLLIKSHMVSVDFPEMMAEIISVQVPKILSGKVKPIYFHTQ,andr,8
+MKDSCITVMAMALLSGFFFFAPASSYNLDVRGARSFSPPRAGRHFGYRVLQVGNGVIVGAPGEGNSTGSLYQCQSGTGHCLPVTLRGSNYTSKYLGMTLATDPTDGSILACDPGLSRTCDQNTYLSGLCYLFRQNLQGPMLQGRPGFQECIKGNVDLVFLFDGSMSLQPDEFQKILDFMKDVMKKLSNTSYQFAAVQFSTSYKTEFDFSDYVKRKDPDALLKHVKHMLLLTNTFGAINYVATEVFREELGARPDATKVLIIITDGEATDSGNIDAAKDIIRYIIGIGKHFQTKESQETLHKFASKPASEFVKILDTFEKLKDLFTELQKKIYVIEGTSKQDLTSFNMELSSSGISADLSRGHAVVGAVGAKDWAGGFLDLKADLQDDTFIGNEPLTPEVRAGYLGYTVTWLPSRQKTSLLASGAPRYQHMGRVLLFQEPQGGGHWSQVQTIHGTQIGSYFGGELCGVDVDQDGETELLLIGAPLFYGEQRGGRVFIYQRRQLGFEEVSELQGDPGYPLGRFGEAITALTDINGDGLVDVAVGAPLEEQGAVYIFNGRHGGLSPQPSQRIEGTQVLSGIQWFGRSIHGVKDLEGDGLADVAVGAESQMIVLSSRPVVDMVTLMSFSPAEIPVHEVECSYSTSNKMKEGVNITICFQIKSLIPQFQGRLVANLTYTLQLDGHRTRRRGLFPGGRHELRRNIAVTTSMSCTDFSFHFPVCVQDLISPINVSLNFSLWEEEGTPRDQRAQGKDIPPILRPSLHSETWEIPFEKNCGEDKKCEANLRVSFSPARSRALRLTAFASLSVELSLSNLEEDAYWVQLDLHFPPGLSFRKVEMLKPHSQIPVSCEELPEESRLLSRALSCNVSSPIFKAGHSVALQMMFNTLVNSSWGDSVELHANVTCNNEDSDLLEDNSATTIIPILYPINILIQDQEDSTLYVSFTPKGPKIHQVKHMYQVRIQPSIHDHNIPTLEAVVGVPQPPSEGPITHQWSVQMEPPVPCHYEDLERLPDAAEPCLPGALFRCPVVFRQEILVQVIGTLELVGEIEASSMFSLCSSLSISFNSSKHFHLYGSNASLAQVVMKVDVVYEKQMLYLYVLSGIGGLLLLLLIFIVLYKVGFFKRNLKEKMEAGRGVPNGIPAEDSEQLASGQEAGDPGCLKPLHEKDSESGGGKD,ital,9
+MAALSGGGGGGAEPGQALFNGDMEPEAGAGAGAAASSAADPAIPEEVWNIKQMIKLTQEHIEALLDKFGGEHNPPSIYLEAYEEYTSKLDALQQREQQLLESLGNGTDFSVSSSASMDTVTSSSSSSLSVLPSSLSVFQNPTDVARSNPKSPQKPIVRVFLPNKQRTVVPARCGVTVRDSLKKALMMRGLIPECCAVYRIQDGEKKPIGWDTDISWLTGEELHVEVLENVPLTTHNFVRKTFFTLAFCDFCRKLLFQGFRCQTCGYKFHQRCSTEVPLMCVNYDQLDLLFVSKFFEHHPIPQEEASLAETALTSGSSPSAPASDSIGPQILTSPSPSKSIPIPQPFRPADEDHRNQFGQRDRSSSAPNVHINTIEPVNIDDLIRDQGFRGDGGSTTGLSATPPASLPGSLTNVKALQKSPGPQRERKSSSSSEDRNRMKTLGRRDSSDDWEIPDGQITVGQRIGSGSFGTVYKGKWHGDVAVKMLNVTAPTPQQLQAFKNEVGVLRKTRHVNILLFMGYSTKPQLAIVTQWCEGSSLYHHLHIIETKFEMIKLIDIARQTAQGMDYLHAKSIIHRDLKSNNIFLHEDLTVKIGDFGLATVKSRWSGSHQFEQLSGSILWMAPEVIRMQDKNPYSFQSDVYAFGIVLYELMTGQLPYSNINNRDQIIFMVGRGYLSPDLSKVRSNCPKAMKRLMAECLKKKRDERPLFPQILASIELLARSLPKIHRSASEPSLNRAGFQTEDFSLYACASPKTPIQAGGYGAFPVH,braf,10
+MTPNSMTENGLTAWDKPKHCPDREHDWKLVGMSEACLHRKSHSERRSTLKNEQSSPHLIQTTWTSSIFHLDHDDVNDQSVSSAQTFQTEEKKCKGYIPSYLDKDELCVVCGDKATGYHYRCITCEGCKGFFRRTIQKNLHPSYSCKYEGKCVIDKVTRNQCQECRFKKCIYVGMATDLVLDDSKRLAKRKLIEENREKRRREELQKSIGHKPEPTDEEWELIKTVTEAHVATNAQGSHWKQKRKFLPEDIGQAPIVNAPEGGKVDLEAFSHFTKIITPAITRVVDFAKKLPMFCELPCEDQIILLKGCCMEIMSLRAAVRYDPESETLTLNGEMAVTRGQLKNGGLGVVSDAIFDLGMSLSSFNLDDTEVALLQAVLLMSSDRPGLACVERIEKYQDSFLLAFEHYINYRKHHVTHFWPKLLMKVTDLRMIGACHASRFLHMKVECPTELFPPLFLEVFED,thb,11
+MEHGTLLAQPGLWTRDTSWALLYFLCYILPQTAPQVLRIGGIFETVENEPVNVEELAFKFAVTSINRNRTLMPNTTLTYDIQRINLFDSFEASRRACDQLALGVAALFGPSHSSSVSAVQSICNALEVPHIQTRWKHPSVDNKDLFYINLYPDYAAISRAILDLVLYYNWKTVTVVYEDSTGLIRLQELIKAPSRYNIKIKIRQLPSGNKDAKPLLKEMKKGKEFYVIFDCSHETAAEILKQILFMGMMTEYYHYFFTTLDLFALDLELYRYSGVNMTGFRLLNIDNPHVSSIIEKWSMERLQAPPRPETGLLDGMMTTEAALMYDAVYMVAIASHRASQLTVSSLQCHRHKPWRLGPRFMNLIKEARWDGLTGHITFNKTNGLRKDFDLDIISLKEEGTEKAAGEVSKHLYKVWKKIGIWNSNSGLNMTDSNKDKSSNITDSLANRTLIVTTILEEPYVMYRKSDKPLYGNDRFEGYCLDLLKELSNILGFIYDVKLVPDGKYGAQNDKGEWNGMVKELIDHRADLAVAPLTITYVREKVIDFSKPFMTLGISILYRKPNGTNPGVFSFLNPLSPDIWMYVLLACLGVSCVLFVIARFTPYEWYNPHPCNPDSDVVENNFTLLNSFWFGVGALMQQGSELMPKALSTRIVGGIWWFFTLIIISSYTANLAAFLTVERMESPIDSADDLAKQTKIEYGAVRDGSTMTFFKKSKISTYEKMWAFMSSRQQTALVRNSDEGIQRVLTTDYALLMESTSIEYVTQRNCNLTQIGGLIDSKGYGVGTPIGSPYRDKITIAILQLQEEGKLHMMKEKWWRGNGCPEEDNKEASALGVENIGGIFIVLAAGLVLSVFVAIGEFIYKSRKNNDIEQAFCFFYGLQCKQTHPTNSTSGTTLSTDLECGKLIREERGIRKQSSVHTV,grik1,12
+MADPAAGPPPSEGEESTVRFARKGALRQKNVHEVKNHKFTARFFKQPTFCSHCTDFIWGFGKQGFQCQVCCFVVHKRCHEFVTFSCPGADKGPASDDPRSKHKFKIHTYSSPTFCDHCGSLLYGLIHQGMKCDTCMMNVHKRCVMNVPSLCGTDHTERRGRIYIQAHIDRDVLIVLVRDAKNLVPMDPNGLSDPYVKLKLIPDPKSESKQKTKTIKCSLNPEWNETFRFQLKESDKDRRLSVEIWDWDLTSRNDFMGSLSFGISELQKASVDGWFKLLSQEEGEYFNVPVPPEGSEANEELRQKFERAKISQGTKVPEEKTTNTVSKFDNNGNRDRMKLTDFNFLMVLGKGSFGKVMLSERKGTDELYAVKILKKDVVIQDDDVECTMVEKRVLALPGKPPFLTQLHSCFQTMDRLYFVMEYVNGGDLMYHIQQVGRFKEPHAVFYAAEIAIGLFFLQSKGIIYRDLKLDNVMLDSEGHIKIADFGMCKENIWDGVTTKTFCGTPDYIAPEIIAYQPYGKSVDWWAFGVLLYEMLAGQAPFEGEDEDELFQSIMEHNVAYPKSMSKEAVAICKGLMTKHPGKRLGCGPEGERDIKEHAFFRYIDWEKLERKEIQPPYKPKARDKRDTSNFDKEFTRQPVELTPTDKLFIMNLDQNEFAGFSYTNPEFVINV,kpcb,13
+FLDGIDKAQEEHEKYHSNWRAMASDFNLPPVVAKEIVASCDKCQLKGEAMHGQVDCSPGIWQLDCTHLEGKVILVAVHVASGYIEAEVIPAETGQETAYFLLKLAGRWPVKTVHTDNGSNFTSTTVKAACWWAGIKQEFGIPYNPQSQGVIESMNKELKKIIGQVRDQAEHLKTAVQMAVFIHNFKRKGGIGGYSAGERIVDIIATDIQTKELQKQITKIQNFRVYYRDSRDPVWKGPAKLLWKGEGAVVIQDNSDIKVVPRRKAKIIRDYGKQMAGDDCVASRQDED,hivint,14
+MAWRHLKKRAQDAVIILGGGGLLFASYLMATGDERFYAEHLMPTLQGLLDPESAHRLAVRFTSLGLLPRARFQDSDMLEVRVLGHKFRNPVGIAAGFDKHGEAVDGLYKMGFGFVEIGSVTPKPQEGNPRPRVFRLPEDQAVINRYGFNSHGLSVVEHRLRARQQKQAKLTEDGLPLGVNLGKNKTSVDAAEDYAEGVRVLGPLADYLVVNVSSPNTAGLRSLQGKAELRRLLTKVLQERDGLRRVHRPAVLVKIAPDLTSQDKEDIASVVKELGIDGLIVTNTTVSRPAGLQGALRSETGGLSGKPLRDLSTQTIREMYALTQGRVPIIGVGGVSSGQDALEKIRAGASLVQLYTALTFWGPPVVGKVKRELEALLKEQGFGGVTDAIGADHRR,pyrd,15
+MENFQKVEKIGEGTYGVVYKARNKLTGEVVALKKIRLDTETEGVPSTAIREISLLKELNHPNIVKLLDVIHTENKLYLVFEFLHQDLKKFMDASALTGIPLPLIKSYLFQLLQGLAFCHSHRVLHRDLKPQNLLINTEGAIKLADFGLARAFGVPVRTYTHEVVTLWYRAPEILLGCKYYSTAVDIWSLGCIFAEMVTRRALFPGDSEIDQLFRIFRTLGTPDEVVWPGVTSMPDYKPSFPKWARQDFSKVVPPLDEDGRSLLSQMLHYDPNKRISAKAALAHPFFQDVTKPVPHLRL,cdk2,16
+MCDAFVGTWKLVSSENFDDYMKEVGVGFATRKVAGMAKPNMIISVNGDVITIKSESTFKNTEISFILGQEFDEVTADDRKVKSTITLDGGVLVHVQKWDGKSTTIKRKREDDKLVVECVMKGVTSTRVYERA,fabp4,17
+MDTKHFLPLDFSTQVNSSLTSPTGRGSMAAPSLHPSLGPGIGSPGQLHSPISTLSSPINGMGPPFSVISSPMGPHSMSVPTTPTLGFSTGSPQLSSPMNPVSSSEDIKPPLGLNGVLKVPAHPSGNMASFTKHICAICGDRSSGKHYGVYSCEGCKGFFKRTVRKDLTYTCRDNKDCLIDKRQRNRCQYCRYQKCLAMGMKREAVQEERQRGKDRNENEVESTSSANEDMPVERILEAELAVEPKTETYVEANMGLNPSSPNDPVTNICQAADKQLFTLVEWAKRIPHFSELPLDDQVILLRAGWNELLIASFSHRSIAVKDGILLATGLHVHRNSAHSAGVGAIFDRVLTELVSKMRDMQMDKTELGCLRAIVLFNPDSKGLSNPAEVEALREKVYASLEAYCKHKYPEQPGRFAKLLLRLPALRSIGLKCLEHLFFFKLIGDTPIDTFLMEMLEAPHQMT,rxra,18
+MNPLLILTFVAAALAAPFDDDDKIVGGYNCEENSVPYQVSLNSGYHFCGGSLINEQWVVSAGHCYKSRIQVRLGEHNIEVLEGNEQFINAAKIIRHPQYDRKTLNNDIMLIKLSSRAVINARVSTISLPTAPPATGTKCLISGWGNTASSGADYPDELQCLDAPVLSQAKCEASYPGKITSNMFCVGFLEGGKDSCQGDSGGPVVCNGQLQGVVSWGDGCAQKNKPGVYTKVYNYVKWIKNTIAANS,try1,19
+MSCINLPTVLPGSPSKTRGQIQVILGPMFSGKSTELMRRVRRFQIAQYKCLVIKYAKDTRYSSSFCTHDRNTMEALPACLLRDVAQEALGVAVIGIDEGQFFPDIVEFCEAMANAGKTVIVAALDGTFQRKPFGAILNLVPLAESVVKLTAVCMECFREAAYTKRLGTEKEVEVIGGADKYHSVCRLCYFKKASGQPAGPDNKENCPVPGKPGEAVAARKLFAPQQILQCSPAN,kith,20
+MALIPDLAMETWLLLAVSLVLLYLYGTHSHGLFKKLGIPGPTPLPFLGNILSYHKGFCMFDMECHKKYGKVWGFYDGQQPVLAITDPDMIKTVLVKECYSVFTNRRPFGPVGFMKSAISIAEDEEWKRLRSLLSPTFTSGKLKEMVPIIAQYGDVLVRNLRREAETGKPVTLKDVFGAYSMDVITSTSFGVNIDSLNNPQDPFVENTKKLLRFDFLDPFFLSITVFPFLIPILEVLNICVFPREVTNFLRKSVKRMKESRLEDTQKHRVDFLQLMIDSQNSKETESHKALSDLELVAQSIIFIFAGYETTSSVLSFIMYELATHPDVQQKLQEEIDAVLPNKAPPTYDTVLQMEYLDMVVNETLRLFPIAMRLERVCKKDVEINGMFIPKGVVVMIPSYALHRDPKYWTEPEKFLPERFSKKNKDNIDPYIYTPFGSGPRNCIGMRFALMNMKLALIRVLQNFSFKPCKETQIPLKLSLGGLLQPEKPVVLKVESRDGTVSGA,cp3a4,21
+MAYSQGGGKKKVCYYYDGDIGNYYYGQGHPMKPHRIRMTHNLLLNYGLYRKMEIYRPHKATAEEMTKYHSDEYIKFLRSIRPDNMSEYSKQMQRFNVGEDCPVFDGLFEFCQLSTGGSVAGAVKLNRQQTDMAVNWAGGLHHAKKSEASGFCYVNDIVLAILELLKYHQRVLYIDIDIHHGDGVEEAFYTTDRVMTVSFHKYGEYFPGTGDLRDIGAGKGKYYAVNFPMRDGIDDESYGQIFKPIISKVMEMYQPSAVVLQCGADSLSGDRLGCFNLTVKGHAKCVEVVKTFNLPLLMLGGGGYTIRNVARCWTYETAVALDCEIPNELPYNDYFEYFGPDFKLHISPSNMTNQNTPEYMEKIKQRLFENLRMLPHAPGVQMQAIPEDAVHEDSGDEDGEDPDKRISIRASDKRIACDEEFSDSEDEGEGGRRNVADHKKGAKKARIEEDKKETEDKKTDVKEEDKSKDNSGEKTDTKGTKSEQLSNP,hdac2,22
+MTELKAKGPRAPHVAGGPPSPEVGSPLLCRPAAGPFPGSQTSDTLPEVSAIPISLDGLLFPRPCQGQDPSDEKTQDQQSLSDVEGAYSRAEATRGAGGSSSSPPEKDSGLLDSVLDTLLAPSGPGQSQPSPPACEVTSSWCLFGPELPEDPPAAPATQRVLSPLMSRSGCKVGDSSGTAAAHKVLPRGLSPARQLLLPASESPHWSGAPVKPSPQAAAVEVEEEDGSESEESAGPLLKGKPRALGGAAAGGGAAAVPPGAAAGGVALVPKEDSRFSAPRVALVEQDAPMAPGRSPLATTVMDFIHVPILPLNHALLAARTRQLLEDESYDGGAGAASAFAPPRSSPCASSTPVAVGDFPDCAYPPDAEPKDDAYPLYSDFQPPALKIKEEEEGAEASARSPRSYLVAGANPAAFPDFPLGPPPPLPPRATPSRPGEAAVTAAPASASVSSASSSGSTLECILYKAEGAPPQQGPFAPPPCKAPGASGCLLPRDGLPSTSASAAAAGAAPALYPALGLNGLPQLGYQAAVLKEGLPQVYPPYLNYLRPDSEASQSPQYSFESLPQKICLICGDEASGCHYGVLTCGSCKVFFKRAMEGQHNYLCAGRNDCIVDKIRRKNCPACRLRKCCQAGMVLGGRKFKKFNKVRVVRALDAVALPQPVGVPNESQALSQRFTFSPGQDIQLIPPLINLLMSIEPDVIYAGHDNTKPDTSSSLLTSLNQLGERQLLSVVKWSKSLPGFRNLHIDDQITLIQYSWMSLMVFGLGWRSYKHVSGQMLYFAPDLILNEQRMKESSFYSLCLTMWQIPQEFVKLQVSQEEFLCMKVLLLLNTIPLEGLRSQTQFEEMRSSYIRELIKAIGLRQKGVVSSSQRFYQLTKLLDNLHDLVKQLHLYCLNTFIQSRALSVEFPEMMSEVIAAQLPKILAGMVKPLLFHKK,prgr,23
+MGSNKSKPKDASQRRRSLEPAENVHGAGGGAFPASQTPSKPASADGHRGPSAAFAPAAAEPKLFGGFNSSDTVTSPQRAGPLAGGVTTFVALYDYESRTETDLSFKKGERLQIVNNTEGDWWLAHSLSTGQTGYIPSNYVAPSDSIQAEEWYFGKITRRESERLLLNAENPRGTFLVRESETTKGAYCLSVSDFDNAKGLNVKHYKIRKLDSGGFYITSRTQFNSLQQLVAYYSKHADGLCHRLTTVCPTSKPQTQGLAKDAWEIPRESLRLEVKLGQGCFGEVWMGTWNGTTRVAIKTLKPGTMSPEAFLQEAQVMKKLRHEKLVQLYAVVSEEPIYIVTEYMSKGSLLDFLKGETGKYLRLPQLVDMAAQIASGMAYVERMNYVHRDLRAANILVGENLVCKVADFGLARLIEDNEYTARQGAKFPIKWTAPEAALYGRFTIKSDVWSFGILLTELTTKGRVPYPGMVNREVLDQVERGYRMPCPPECPESLHDLMCQCWRKEPEERPTFEYLQAFLEDYFTSTEPQYQPGENL,src,24
+MTFNSFEGSKTCVPADINKEEEFVEEFNRLKTFANFPSGSPVSASTLARAGFLYTGEGDTVRCFSCHAAVDRWQYGDSAVGRHRKVSPNCRFINGFYLENSATQSTNSGIQNGQYKVENYLGSRDHFALDRPSETHADYLLRTGQVVDISDTIYPRNPAMYSEEARLKSFQNWPDYAHLTPRELASAGLYYTGIGDQVQCFCCGGKLKNWEPCDRAWSEHRRHFPNCFFVLGRNLNIRSESDAVSSDRNFPNSTNLPRNPSMADYEARIFTFGTWIYSVNKEQLARAGFYALGEGDKVKCFHCGGGLTDWKPSEDPWEQHAKWYPGCKYLLEQKGQEYINNIHLTHSLEECLVRTTEKTPSLTRRIDDTIFQNPMVQEAIRMGFSFKDIKKIMEEKIQISGSNYKSLEVLVADLVNAQKDSMQDESSQTSLQKEISTEEQLRRLQEEKLCKICMDRNIAIVFVPCGHLVTCKQCAEAVDKCPMCYTVITFKQKIFMS,xiap,25
+MSRSLLLWFLLFLLLLPPLPVLLADPGAPTPVNPCCYYPCQHQGICVRFGLDRYQCDCTRTGYSGPNCTIPGLWTWLRNSLRPSPSFTHFLLTHGRWFWEFVNATFIREMLMRLVLTVRSNLIPSPPTYNSAHDYISWESFSNVSYYTRILPSVPKDCPTPMGTKGKKQLPDAQLLARRFLLRRKFIPDPQGTNLMFAFFAQHFTHQFFKTSGKMGPGFTKALGHGVDLGHIYGDNLERQYQLRLFKDGKLKYQVLDGEMYPPSVEEAPVLMHYPRGIPPQSQMAVGQEVFGLLPGLMLYATLWLREHNRVCDLLKAEHPTWGDEQLFQTTRLILIGETIKIVIEEYVQQLSGYFLQLKFDPELLFGVQFQYRNRIAMEFNHLYHWHPLMPDSFKVGSQEYSYEQFLFNTSMLVDYGVEALVDAFSRQIAGRIGGGRNMDHHILHVAVDVIRESREMRLQPFNEYRKRFGMKPYTSFQELVGEKEMAAELEELYGDIDALEFYPGLLLEKCHPNSIFGESMIEIGAPFSLKGLLGNPICSPEYWKPSTFGGEVGFNIVKTATLKKLVCLNTKTCPYVSFRVPDASQDDGPAVERPSTEL,pgh1,26
+MVDTESPLCPLSPLEAGDLESPLSEEFLQEMGNIQEISQSIGEDSSGSFGFTEYQYLGSCPGSDGSVITDTLSPASSPSSVTYPVVPGSVDESPSGALNIECRICGDKASGYHYGVHACEGCKGFFRRTIRLKLVYDKCDRSCKIQKKNRNKCQYCRFHKCLSVGMSHNAIRFGRMPRSEKAKLKAEILTCEHDIEDSETADLKSLAKRIYEAYLKNFNMNKVKARVILSGKASNNPPFVIHDMETLCMAEKTLVAKLVANGIQNKEAEVRIFHCCQCTSVETVTELTEFAKAIPGFANLDLNDQVTLLKYGVYEAIFAMLSSVMNKDGMLVAYGNGFITREFLKSLRKPFCDIMEPKFDFAMKFNALELDDSDISLFVAAIICCGDRPGLLNVGHIEKMQEGIVHVLRLHLQSNHPDDIFLFPKLLQKMADLRQLVTEHAQLVQIIKKTESDAALHPLLQEIYRDMY,ppara,27
+MAATEGVGEAAQGGEPGQPAQPPPQPHPPPPQQQHKEEMAAEAGEAVASPMDDGFVSLDSPSYVLYRDRAEWADIDPVPQNDGPNPVVQIIYSDKFRDVYDYFRAVLQRDERSERAFKLTRDAIELNAANYTVWHFRRVLLKSLQKDLHEEMNYITAIIEEQPKNYQVWHHRRVLVEWLRDPSQELEFIADILNQDAKNYHAWQHRQWVIQEFKLWDNELQYVDQLLKEDVRNNSVWNQRYFVISNTTGYNDRAVLEREVQYTLEMIKLVPHNESAWNYLKGILQDRGLSKYPNLLNQLLDLQPSHSSPYLIAFLVDIYEDMLENQCDNKEDILNKALELCEILAKEKDTIRKEYWRYIGRSLQSKHSTENDSPTNVQQ,fnta,28
+MPEAPPLLLAAVLLGLVLLVVLLLLLRHWGWGLCLIGWNEFILQPIHNLLMGDTKEQRILNHVLQHAEPGNAQSVLEAIDTYCEQKEWAMNVGDKKGKIVDAVIQEHQPSVLLELGAYCGYSAVRMARLLSPGARLITIEINPDCAAITQRMVDFAGVKDKVTLVVGASQDIIPQLKKKYDVDTLDMVFLDHWKDRYLPDTLLLEECGLLRKGTVLLADNVICPGAPDFLAHVRGSSCFECTHYQSFLEYREVVDGLEKAIYKGPGSEAGP,comt,29
+MEGISIYTSDNYTEEMGSGDYDSMKEPCFREENANFNKIFLPTIYSIIFLTGIVGNGLVILVMGYQKKLRSMTDKYRLHLSVADLLFVITLPFWAVDAVANWYFGNFLCKAVHVIYTVNLYSSVLILAFISLDRYLAIVHATNSQRPRKLLAEKVVYVGVWIPALLLTIPDFIFANVSEADDRYICDRFYPNDLWVVVFQFQHIMVGLILPGIVILSCYCIIISKLSHSKGHQKRKALKTTVILILAFFACWLPYYIGISIDSFILLEIIKQGCEFENTVHKWISITEALAFFHCCLNPILYAFLGAKFKTSAQHALTSVSRGSSLKILSKGKRGGHSSVSTESESSSFHSS,cxcr4,30
+MPVAGSELPRRPLPPAAQERDAEPRPPHGELQYLGQIQHILRCGVRKDDRTGTGTLSVFGMQARYSLRDEFPLLTTKRVFWKGVLEELLWFIKGSTNAKELSSKGVKIWDANGSRDFLDSLGFSTREEGDLGPVYGFQWRHFGAEYRDMESDYSGQGVDQLQRVIDTIKTNPDDRRIIMCAWNPRDLPLMALPPCHALCQFYVVNSELSCQLYQRSGDMGLGVPFNIASYALLTYMIAHITGLKPGDFIHTLGDAHIYLNHIEPLKIQLQREPRPFPKLRILRKVEKIDDFKAEDFQIEGYNPHPTIKMEMAV,tysy,31
+PQITLWQRPLVTIKIGGQLKEALLDTGADDTVLEEMNLPGKWKPKMIGGIGGFIKVRQYDQILIEICGHKAIGTVLVGPTPVNIIGRNLLTQIGCTLNFP,hivpr,32
+MKAPAVLAPGILVLLFTLVQRSNGECKEALAKSEMNVNMKYQLPNFTAETPIQNVILHEHHIFLGATNYIYVLNEEDLQKVAEYKTGPVLEHPDCFPCQDCSSKANLSGGVWKDNINMALVVDTYYDDQLISCGSVNRGTCQRHVFPHNHTADIQSEVHCIFSPQIEEPSQCPDCVVSALGAKVLSSVKDRFINFFVGNTINSSYFPDHPLHSISVRRLKETKDGFMFLTDQSYIDVLPEFRDSYPIKYVHAFESNNFIYFLTVQRETLDAQTFHTRIIRFCSINSGLHSYMEMPLECILTEKRKKRSTKKEVFNILQAAYVSKPGAQLARQIGASLNDDILFGVFAQSKPDSAEPMDRSAMCAFPIKYVNDFFNKIVNKNNVRCLQHFYGPNHEHCFNRTLLRNSSGCEARRDEYRTEFTTALQRVDLFMGQFSEVLLTSISTFIKGDLTIANLGTSEGRFMQVVVSRSGPSTPHVNFLLDSHPVSPEVIVEHTLNQNGYTLVITGKKITKIPLNGLGCRHFQSCSQCLSAPPFVQCGWCHDKCVRSEECLSGTWTQQICLPAIYKVFPNSAPLEGGTRLTICGWDFGFRRNNKFDLKKTRVLLGNESCTLTLSESTMNTLKCTVGPAMNKHFNMSIIISNGHGTTQYSTFSYVDPVITSISPKYGPMAGGTLLTLTGNYLNSGNSRHISIGGKTCTLKSVSNSILECYTPAQTISTEFAVKLKIDLANRETSIFSYREDPIVYEIHPTKSFISGGSTITGVGKNLNSVSVPRMVINVHEAGRNFTVACQHRSNSEIICCTTPSLQQLNLQLPLKTKAFFMLDGILSKYFDLIYVHNPVFKPFEKPVMISMGNENVLEIKGNDIDPEAVKGEVLKVGNKSCENIHLHSEAVLCTVPNDLLKLNSELNIEWKQAISSTVLGKVIVQPDQNFTGLIAGVVSISTALLLLLGFFLWLKKRKQIKDLGSELVRYDARVHTPHLDRLVSARSVSPTTEMVSNESVDYRATFPEDQFPNSSQNGSCRQVQYPLTDMSPILTSGDSDISSPLLQNTVHIDLSALNPELVQAVQHVVIGPSSLIVHFNEVIGRGHFGCVYHGTLLDNDGKKIHCAVKSLNRITDIGEVSQFLTEGIIMKDFSHPNVLSLLGICLRSEGSPLVVLPYMKHGDLRNFIRNETHNPTVKDLIGFGLQVAKGMKYLASKKFVHRDLAARNCMLDEKFTVKVADFGLARDMYDKEYYSVHNKTGAKLPVKWMALESLQTQKFTTKSDVWSFGVLLWELMTRGAPPYPDVNTFDITVYLLQGRRLLQPEYCPDPLYEVMLKCWHPKAEMRPSFSELVSRISAIFSTFIGEHYVHVNATYVNVKCVAPYPSLLSSEDNADDEVDTRPASFWETS,met,33
+MVLHLLLFLLLTPQGGHSCQGLELARELVLAKVRALFLDALGPPAVTREGGDPGVRRLPRRHALGGFTHRGSEPEEEEDVSQAILFPATDASCEDKSAARGLAQEAEEGLFRYMFRPSQHTRSRQVTSAQLWFHTGLDRQGTAASNSSEPLLGLLALSPGGPVAVPMSLGHAPPHWAVLHLATSALSLLTHPVLVLLLRCPLCTCSARPEATPFLVAHTRTRPPSGGERARRSTPLMSWPWSPSALRLLQRPPEEPAAHANCHRVALNISFQELGWERWIVYPPSFIFHYCHGGCGLHIPPNLSLPVPGAPPTPAQPYSLLPGAQPCCAALPGTMRPLHVRTTSDGGYSFKYETVPNLLTQHCACI,inha,34
+MEEPEEPADSGQSLVPVYIYSPEYVSMCDSLAKIPKRASMVHSLIEAYALHKQMRIVKPKVASMEEMATFHTDAYLQHLQKVSQEGDDDHPDSIEYGLGYDCPATEGIFDYAAAIGGATITAAQCLIDGMCKVAINWSGGWHHAKKDEASGFCYLNDAVLGILRLRRKFERILYVDLDLHHGDGVEDAFSFTSKVMTVSLHKFSPGFFPGTGDVSDVGLGKGRYYSVNVPIQDGIQDEKYYQICESVLKEVYQAFNPKAVVLQLGADTIAGDPMCSFNMTPVGIGKCLKYILQWQLATLILGGGGYNLANTARCWTYLTGVILGKTLSSEIPDHEFFTAYGPDYVLEITPSCRPDRNEPHRIQQILNYIKGNLKHVV,hdac8,35
+MENTENSVDSKSIKNLEPKIIHGSESMDSGISLDNSYKMDYPEMGLCIIINNKNFHKSTGMTSRSGTDVDAANLRETFRNLKYEVRNKNDLTREEIVELMRDVSKEDHSKRSSFVCVLLSHGEEGIIFGTNGPVDLKKITNFFRGDRCRSLTGKPKLFIIQACRGTELDCGIETDSGVDDDMACHKIPVEADFLYAYSTAPGYYSWRNSKDGSWFIQSLCAMLKQYADKLEFMHILTRVNRKVATEFESFSFDATFHAKKQIPCIVSMLTKELYFYH,bace1,36
+MSHHWGYGKHNGPEHWHKDFPIAKGERQSPVDIDTHTAKYDPSLKPLSVSYDQATSLRILNNGHAFNVEFDDSQDKAVLKGGPLDGTYRLIQFHFHWGSLDGQGSEHTVDKKKYAAELHLVHWNTKYGDFGKAVQQPDGLAVLGIFLKVGSAKPGLQKVVDVLDSIKTKGKSADFTNFDPRGLLPESLDYWTYPGSLTTPPLLECVTWIVLKEPISVSSEQVLKFRKLNFNGEGEPEELMVDNWRPAQPLKNRQIKASFK,cah2,37
+MRGARGAWDFLCVLLLLLRVQTGSSQPSVSPGEPSPPSIHPGKSDLIVRVGDEIRLLCTDPGFVKWTFEILDETNENKQNEWITEKAEATNTGKYTCTNKHGLSNSIYVFVRDPAKLFLVDRSLYGKEDNDTLVRCPLTDPEVTNYSLKGCQGKPLPKDLRFIPDPKAGIMIKSVKRAYHRLCLHCSVDQEGKSVLSEKFILKVRPAFKAVPVVSVSKASYLLREGEEFTVTCTIKDVSSSVYSTWKRENSQTKLQEKYNSWHHGDFNYERQATLTISSARVNDSGVFMCYANNTFGSANVTTTLEVVDKGFINIFPMINTTVFVNDGENVDLIVEYEAFPKPEHQQWIYMNRTFTDKWEDYPKSENESNIRYVSELHLTRLKGTEGGTYTFLVSNSDVNAAIAFNVYVNTKPEILTYDRLVNGMLQCVAAGFPEPTIDWYFCPGTEQRCSASVLPVDVQTLNSSGPPFGKLVVQSSIDSSAFKHNGTVECKAYNDVGKTSAYFNFAFKGNNKEQIHPHTLFTPLLIGFVIVAGMMCIIVMILTYKYLQKPMYEVQWKVVEEINGNNYVYIDPTQLPYDHKWEFPRNRLSFGKTLGAGAFGKVVEATAYGLIKSDAAMTVAVKMLKPSAHLTEREALMSELKVLSYLGNHMNIVNLLGACTIGGPTLVITEYCCYGDLLNFLRRKRDSFICSKQEDHAEAALYKNLLHSKESSCSDSTNEYMDMKPGVSYVVPTKADKRRSVRIGSYIERDVTPAIMEDDELALDLEDLLSFSYQVAKGMAFLASKNCIHRDLAARNILLTHGRITKICDFGLARDIKNDSNYVVKGNARLPVKWMAPESIFNCVYTFESDVWSYGIFLWELFSLGSSPYPGMPVDSKFYKMIKEGFRMLSPEHAPAEMYDIMKTCWDADPLKRPTFKQIVQLIEKQISESTNHIYSNLANCSPNRQKPVVDHSVRINSVGSTASSSQPLLVHDDV,kit,38
+MPKKKPTPIQLNPAPDGSAVNGTSSAETNLEALQKKLEELELDEQQRKRLEAFLTQKQKVGELKDDDFEKISELGAGNGGVVFKVSHKPSGLVMARKLIHLEIKPAIRNQIIRELQVLHECNSPYIVGFYGAFYSDGEISICMEHMDGGSLDQVLKKAGRIPEQILGKVSIAVIKGLTYLREKHKIMHRDVKPSNILVNSRGEIKLCDFGVSGQLIDSMANSFVGTRSYMSPERLQGTHYSVQSDIWSMGLSLVEMAVGRYPIPPPDAKELELMFGCQVEGDAAETPPRPRTPGRPLSSYGMDSRPPMAIFELLDYIVNEPPPKLPSGVFSLEFQDFVNKCLIKNPAERADLKQLMVHAFIKRSDAEEVDFAGWLCSTIGLNQPSTPTHAAGV,mp2k1,39
+MPIMGSSVYITVELAIAVLAILGNVLVCWAVWLNSNLQNVTNYFVVSLAAADIAVGVLAIPFAITISTGFCAACHGCLFIACFVLVLTQSSIFSLLAIAIDRYIAIRIPLRYNGLVTGTRAKGIIAICWVLSFAIGLTPMLGWNNCGQPKEGKNHSQGCGEGQVACLFEDVVPMNYMVYFNFFACVLVPLLLMLGVYLRIFLAARRQLKQMESQPLPGERARSTLQKEVHAAKSLAIIVGLFALCWLPLHIINCFTFFCPDCSHAPLWLMYLAIVLSHTNSVVNPFIYAYRIREFRQTFRKIIRSHVLRQQEPFKAAGTSARVLAAHGSDGEQVSLRLNGHPPGVWANGSAPHPERRPNGYALGLVSGGSAQESQGNTGLPDVELLSHELKGVCPEPPGLDDPLAQDGAGVS,aa2ar,40
+MVSQALRLLCLLLGLQGCLAAGGVAKASGGETRDMPWKPGPHRVFVTQEEAHGVLHRRRRANAFLEELRPGSLERECKEEQCSFEEAREIFKDAERTKLFWISYSDGDQCASSPCQNGGSCKDQLQSYICFCLPAFEGRNCETHKDDQLICVNENGGCEQYCSDHTGTKRSCRCHEGYSLLADGVSCTPTVEYPCGKIPILEKRNASKPQGRIVGGKVCPKGECPWQVLLLVNGAQLCGGTLINTIWVVSAAHCFDKIKNWRNLIAVLGEHDLSEHDGDEQSRRVAQVIIPSTYVPGTTNHDIALLRLHQPVVLTDHVVPLCLPERTFSERTLAFVRFSLVSGWGQLLDRGATALELMVLNVPRLMTQDCLQQSRKVGDSPNITEYMFCAGYSDGSKDSCKGDSGGPHATHYRGTWYLTGIVSWGQGCATVGHFGVYTRVSQYIEWLQKLMRSEPRPGVLLRAPFP,fa7,41
+MEAAVAAPRPRLLLLVLAAAAAAAAALLPGATALQCFCHLCTKDNFTCVTDGLCFVSVTETTDKVIHNSMCIAEIDLIPRDRPFVCAPSSKTGSVTTTYCCNQDHCNKIELPTTVKSSPGLGPVELAAVIAGPVCFVCISLMLMVYICHNRTVIHHRVPNEEDPSLDRPFISEGTTLKDLIYDMTTSGSGSGLPLLVQRTIARTIVLQESIGKGRFGEVWRGKWRGEEVAVKIFSSREERSWFREAEIYQTVMLRHENILGFIAADNKDNGTWTQLWLVSDYHEHGSLFDYLNRYTVTVEGMIKLALSTASGLAHLHMEIVGTQGKPAIAHRDLKSKNILVKKNGTCCIADLGLAVRHDSATDTIDIAPNHRVGTKRYMAPEVLDDSINMKHFESFKRADIYAMGLVFWEIARRCSIGGIHEDYQLPYYDLVPSDPSVEEMRKVVCEQKLRPNIPNRWQSCEALRVMAKIMRECWYANGAARLTALRIKKTLSQLSQQEGIKM,tgfr1,42
+MKSGSGGGSPTSLWGLLFLSAALSLWPTSGEICGPGIDIRNDYQQLKRLENCTVIEGYLHILLISKAEDYRSYRFPKLTVITEYLLLFRVAGLESLGDLFPNLTVIRGWKLFYNYALVIFEMTNLKDIGLYNLRNITRGAIRIEKNADLCYLSTVDWSLILDAVSNNYIVGNKPPKECGDLCPGTMEEKPMCEKTTINNEYNYRCWTTNRCQKMCPSTCGKRACTENNECCHPECLGSCSAPDNDTACVACRHYYYAGVCVPACPPNTYRFEGWRCVDRDFCANILSAESSDSEGFVIHDGECMQECPSGFIRNGSQSMYCIPCEGPCPKVCEEEKKTKTIDSVTSAQMLQGCTIFKGNLLINIRRGNNIASELENFMGLIEVVTGYVKIRHSHALVSLSFLKNLRLILGEEQLEGNYSFYVLDNQNLQQLWDWDHRNLTIKAGKMYFAFNPKLCVSEIYRMEEVTGTKGRQSKGDINTRNNGERASCESDVLHFTSTTTSKNRIIITWHRYRPPDYRDLISFTVYYKEAPFKNVTEYDGQDACGSNSWNMVDVDLPPNKDVEPGILLHGLKPWTQYAVYVKAVTLTMVENDHIRGAKSEILYIRTNASVPSIPLDVLSASNSSSQLIVKWNPPSLPNGNLSYYIVRWQRQPQDGYLYRHNYCSKDKIPIRKYADGTIDIEEVTENPKTEVCGGEKGPCCACPKTEAEKQAEKEEAEYRKVFENFLHNSIFVPRPERKRRDVMQVANTTMSSRSRNTTAADTYNITDPEELETEYPFFESRVDNKERTVISNLRPFTLYRIDIHSCNHEAEKLGCSASNFVFARTMPAEGADDIPGPVTWEPRPENSIFLKWPEPENPNGLILMYEIKYGSQVEDQRECVSRQEYRKYGGAKLNRLNPGNYTARIQATSLSGNGSWTDPVFFYVQAKTGYENFIHLIIALPVAVLLIVGGLVIMLYVFHRKRNNSRLGNGVLYASVNPEYFSAADVYVPDEWEVAREKITMSRELGQGSFGMVYEGVAKGVVKDEPETRVAIKTVNEAASMRERIEFLNEASVMKEFNCHHVVRLLGVVSQGQPTLVIMELMTRGDLKSYLRSLRPEMENNPVLAPPSLSKMIQMAGEIADGMAYLNANKFVHRDLAARNCMVAEDFTVKIGDFGMTRDIYETDYYRKGGKGLLPVRWMSPESLKDGVFTTYSDVWSFGVVLWEIATLAEQPYQGLSNEQVLRFVMEGGLLDKPDNCPDMLFELMRMCWQYNPKMRPSFLEIISSIKEEMEPGFREVSFYYSEENKLPEPEELDLEPENMESVPLDPSASSSSLPLPDRHSGHKAENGPGPGVLVLRASFDERQPYAHMNGGRKNERALPLPQSSTC,igf1r,43
+MSAAVTAGKLARAPADPGKAGVPGVAAPGAPAAAPPAKEIPEVLVDPRSRRRYVRGRFLGKGGFAKCFEISDADTKEVFAGKIVPKSLLLKPHQREKMSMEISIHRSLAHQHVVGFHGFFEDNDFVFVVLELCRRRSLLELHKRRKALTEPEARYYLRQIVLGCQYLHRNRVIHRDLKLGNLFLNEDLEVKIGDFGLATKVEYDGERKKTLCGTPNYIAPEVLSKKGHSFEVDVWSIGCIMYTLLVGKPPFETSCLKETYLRIKKNEYSIPKHINPVAASLIQKMLQTDPTARPTINELLNDEFFTSGYIPARLPITCLTIPPRFSIAPSSLDPSNRKPLTVLNKGLENPLPERPREKEEPVVRETGEVVDCHLSDMLQQLHSVNASKPSERGLVRQEEAEDPACIPIFWVSKWVDYSDKYGLGYQLCDNSVGVLFNDSTRLILYNDGDSLQYIERDGTESYLTVSSHPNSLMKKITLLKYFRNYMSEHLLKAGANITPREGDELARLPYLRTWFRTRSAIILHLSNGSVQINFFQDHTKLILCPLMAAVTYIDEKRDFRTYRLSLLEEYGCCKELASRLRYARTMVDKLLSSRSASNRLKAS,plk1,44
+MSVLQVLHIPDERLRKVAKPVEEVNAEIQRIVDDMFETMYAEEGIGLAATQVDIHQRIIVIDVSENRDERLVLINPELLEKSGETGIEEGCLSIPEQRALVPRAEKVKIRALDRDGKPFELEADGLLAICIQHEMDHLVGKLFMDYLSPLKQQRIRQKVEKLDRLKARA,def,45
+MSDKLPYKVADIGLAAWGRKALDIAENEMPGLMRMRERYSASKPLKGARIAGCLHMTVETAVLIETLVTLGAEVQWSSCNIFSTQDHAAAAIAKAGIPVYAWKGETDEEYLWCIEQTLYFKDGPLNMILDDGGDLTNLIHTKYPQLLPGIRGISEETTTGVHNLYKMMANGILKVPAINVNDSVTKSKFDNLYGCRESLIDGIKRATDVMIAGKVAVVAGYGDVGKGCAQALRGFGARVIITEIDPINALQAAMEGYEVTTMDEACQEGNIFVTTTGCIDIILGRHFEQMKDDAIVCNIGHFDVEIDVKWLNENAVEKVNIKPQVDRYRLKNGRRIILLAEGRLVNLGCAMGHPSFVMSNSFTNQVMAQIELWTHPDKYPVGVHFLPKKLDEAVAEAHLGKLNVKLTKLTEKQAQYLGMSCDGPFKPDHYRY,sahh,46
+MPLSRWLRSVGVFLLPAPYWAPRERWLGSLRRPSLVHGYPVLAWHSARCWCQAWTEEPRALCSSLRMNGDQNSDVYAQEKQDFVQHFSQIVRVLTEDEMGHPEIGDAIARLKEVLEYNAIGGKYNRGLTVVVAFRELVEPRKQDADSLQRAWTVGWCVELLQAFFLVADDIMDSSLTRRGQICWYQKPGVGLDAINDANLLEACIYRLLKLYCREQPYYLNLIELFLQSSYQTEIGQTLDLLTAPQGNVDLVRFTEKRYKSIVKYKTAFYSFYLPIAAAMYMAGIDGEKEHANAKKILLEMGEFFQIQDDYLDLFGDPSVTGKIGTDIQDNKCSWLVVQCLQRATPEQYQILKENYGQKEAEKVARVKALYEELDLPAVFLQYEEDSYSHIMALIEQYAAPLPPAVFLGLARKIYKRRK,fpps,47
+MERAGPSFGQQRQQQQPQQQKQQQRDQDSVEAWLDDHWDFTFSYFVRKATREMVNAWFAERVHTIPVCKEGIRGHTESCSCPLQQSPRADNSAPGTPTRKISASEFDRPLRPIVVKDSEGTVSFLSDSEKKEQMPLTPPRFDHDEGDQCSRLLELVKDISSHLDVTALCHKIFLHIHGLISADRYSLFLVCEDSSNDKFLISRLFDVAEGSTLEEVSNNCIRLEWNKGIVGHVAALGEPLNIKDAYEDPRFNAEVDQITGYKTQSILCMPIKNHREEVVGVAQAINKKSGNGGTFTEKDEKDFAAYLAFCGIVLHNAQLYETSLLENKRNQVLLDLASLIFEEQQSLEVILKKIAATIISFMQVQKCTIFIVDEDCSDSFSSVFHMECEELEKSSDTLTREHDANKINYMYAQYVKNTMEPLNIPDVSKDKRFPWTTENTGNVNQQCIRSLLCTPIKNGKKNKVIGVCQLVNKMEENTGKVKPFNRNDEQFLEAFVIFCGLGIQNTQMYEAVERAMAKQMVTLEVLSYHASAAEEETRELQSLAAAVVPSAQTLKITDFSFSDFELSDLETALCTIRMFTDLNLVQNFQMKHEVLCRWILSVKKNYRKNVAYHNWRHAFNTAQCMFAALKAGKIQNKLTDLEILALLIAALSHDLDHRGVNNSYIQRSEHPLAQLYCHSIMEHHHFDQCLMILNSPGNQILSGLSIEEYKTTLKIIKQAILATDLALYIKRRGEFFELIRKNQFNLEDPHQKELFLAMLMTACDLSAITKPWPIQQRIAELVATEFFDQGDRERKELNIEPTDLMNREKKNKIPSMQVGFIDAICLQLYEALTHVSEDCFPLLDGCRKNRQKWQALAEQQEKMLINGESGQAKRN,pde5a,48
+MDGWRRMPRWGLLLLLWGSCTFGLPTDTTTFKRIFLKRMPSIRESLKERGVDMARLGPEWSQPMKRLTLGNTTSSVILTNYMDTQYYGEIGIGTPPQTFKVVFDTGSSNVWVPSSKCSRLYTACVYHKLFDASDSSSYKHNGTELTLRYSTGTVSGFLSQDIITVGGITVTQMFGEVTEMPALPFMLAEFDGVVGMGFIEQAIGRVTPIFDNIISQGVLKEDVFSFYYNRDSENSQSLGGQIVLGGSDPQHYEGNFHYINLIKTGVWQIQMKGVSVGSSTLLCEDGCLALVDTGASYISGSTSSIEKLMEALGAKKRLFDYVVKCNEGPTLPDISFHLGGKEYTLTSADYVFQESYSSKKLCTLAIHAMDIPPPTGPTWALGATFIRKFYTEFDRRNNRIGFALAR,reni,49
+MLDDRARMEAAKKEKVEQILAEFQLQEEDLKKVMRRMQKEMDRGLRLETHEEASVKMLPTYVRSTPEGSEVGDFLSLDLGGTNFRVMLVKVGEGEEGQWSVKTKHQMYSIPEDAMTGTAEMLFDYISECISDFLDKHQMKHKKLPLGFTFSFPVRHEDIDKGILLNWTKGFKASGAEGNNVVGLLRDAIKRRGDFEMDVVAMVNDTVATMISCYYEDHQCEVGMIVGTGCNACYMEEMQNVELVEGDEGRMCVNTEWGAFGDSGELDEFLLEYDRLVDESSANPGQQLYEKLIGGKYMGELVRLVLLRLVDENLLFHGEASEQLRTRGAFETRFVSQVESDTGDRKQIYNILSTLGLRPSTTDCDIVRRACESVSTRAAHMCSAGLAGVINRMRESRSEDVMRITVGVDGSVYKLHPSFKERFHASVRRLTPSCEITFIESEEGSGRGAALVSAVACKKACMLGQ,hxk4,50
+MRPSGTAGAALLALLAALCPASRALEEKKVCQGTSNKLTQLGTFEDHFLSLQRMFNNCEVVLGNLEITYVQRNYDLSFLKTIQEVAGYVLIALNTVERIPLENLQIIRGNMYYENSYALAVLSNYDANKTGLKELPMRNLQEILHGAVRFSNNPALCNVESIQWRDIVSSDFLSNMSMDFQNHLGSCQKCDPSCPNGSCWGAGEENCQKLTKIICAQQCSGRCRGKSPSDCCHNQCAAGCTGPRESDCLVCRKFRDEATCKDTCPPLMLYNPTTYQMDVNPEGKYSFGATCVKKCPRNYVVTDHGSCVRACGADSYEMEEDGVRKCKKCEGPCRKVCNGIGIGEFKDSLSINATNIKHFKNCTSISGDLHILPVAFRGDSFTHTPPLDPQELDILKTVKEITGFLLIQAWPENRTDLHAFENLEIIRGRTKQHGQFSLAVVSLNITSLGLRSLKEISDGDVIISGNKNLCYANTINWKKLFGTSGQKTKIISNRGENSCKATGQVCHALCSPEGCWGPEPRDCVSCRNVSRGRECVDKCNLLEGEPREFVENSECIQCHPECLPQAMNITCTGRGPDNCIQCAHYIDGPHCVKTCPAGVMGENNTLVWKYADAGHVCHLCHPNCTYGCTGPGLEGCPTNGPKIPSIATGMVGALLLLLVVALGIGLFMRRRHIVRKRTLRRLLQERELVEPLTPSGEAPNQALLRILKETEFKKIKVLGSGAFGTVYKGLWIPEGEKVKIPVAIKELREATSPKANKEILDEAYVMASVDNPHVCRLLGICLTSTVQLITQLMPFGCLLDYVREHKDNIGSQYLLNWCVQIAKGMNYLEDRRLVHRDLAARNVLVKTPQHVKITDFGLAKLLGAEEKEYHAEGGKVPIKWMALESILHRIYTHQSDVWSYGVTVWELMTFGSKPYDGIPASEISSILEKGERLPQPPICTIDVYMIMVKCWMIDADSRPKFRELIIEFSKMARDPQRYLVIQGDERMHLPSPTDSNFYRALMDEEDMDDVVDADEYLIPQQGFFSSPSTSRTPLLSSLSATSNNSTVACIDRNGLQSCPIKEDSFLQRYSSDPTGALTEDSIDDTFLPVPEYINQSVPKRPAGSVQNPVYHNQPLNPAPSRDPHYQDPHSTAVGNPEYLNTVQPTCVNSTFDSPAHWAQKGSHQISLDNPDYQQDFFPKEAKPNGIFKGSTAENAEYLRVAPQSSEFIGA,egfr,51
+MPEIVDTCSLASPASVCRTKHLHLRCSVDFTRRTLTGTAALTVQSQEDNLRSLVLDTKDLTIEKVVINGQEVKYALGERQSYKGSPMEISLPIALSKNQEIVIEISFETSPKSSALQWLTPEQTSGKEHPYLFSQCQAIHCRAILPCQDTPSVKLTYTAEVSVPKELVALMSAIRDGETPDPEDPSRKIYKFIQKVPIPCYLIALVVGALESRQIGPRTLVWSEKEQVEKSAYEFSETESMLKIAEDLGGPYVWGQYDLLVLPPSFPYGGMENPCLTFVTPTLLAGDKSLSNVIAHEISHSWTGNLVTNKTWDHFWLNEGHTVYLERHICGRLFGEKFRHFNALGGWGELQNSVKTFGETHPFTKLVVDLTDIDPDVAYSSVPYEKGFALLFYLEQLLGGPEIFLGFLKAYVEKFSYKSITTDDWKDFLYSYFKDKVDVLNQVDWNAWLYSPGLPPIKPNYDMTLTNACIALSQRWITAKEDDLNSFNATDLKDLSSHQLNEFLAQTLQRAPLPLGHIKRMQEVYNFNAINNSEIRFRWLRLCIQSKWEDAIPLALKMATEQGRMKFTRPLFKDLAAFDKSHDQAVRTYQEHKASMHPVTAMLVGKDLKVD,lkha4,52
+MSLHFLYYCSEPTLDVKIAFCQGFDKQVDVSYIAKHYNMSKSKVDNQFYSVEVGDSTFTVLKRYQNLKPIGSGAQGIVCAAYDAVLDRNVAIKKLSRPFQNQTHAKRAYRELVLMKCVNHKNIISLLNVFTPQKTLEEFQDVYLVMELMDANLCQVIQMELDHERMSYLLYQMLCGIKHLHSAGIIHRDLKPSNIVVKSDCTLKILDFGLARTAGTSFMMTPYVVTRYYRAPEVILGMGYKENVDIWSVGCIMGEMVRHKILFPGRDYIDQWNKVIEQLGTPCPEFMKKLQPTVRNYVENRPKYAGLTFPKLFPDSLFPADSEHNKLKASQARDLLSKMLVIDPAKRISVDDALQHPYINVWYDPAEVEAPPPQIYDKQLDEREHTIEEWKELIYKEVMNSEEKTKNGVVKGQPSPSGAAVNSSESLPPSSSVNDISSMSTDQTLASDTDSSLEASAGPLGCCR,mk10,53
+MLSRLFRMHGLFVASHPWEVIVGTVTLTICMMSMNMFTGNNKICGWNYECPKFEEDVLSSDIIILTITRCIAILYIYFQFQNLRQLGSKYILGIAGLFTIFSSFVFSTVVIHFLDKELTGLNEALPFFLLLIDLSRASTLAKFALSSNSQDEVRENIARGMAILGPTFTLDALVECLVIGVGTMSGVRQLEIMCCFGCMSVLANYFVFMTFFPACVSLVLELSRESREGRPIWQLSHFARVLEEEENKPNPVTQRVKMIMSLGLVLVHAHSRWIADPSPQNSTADTSKVSLGLDENVSKRIEPSVSLWQFYLSKMISMDIEQVITLSLALLLAVKYIFFEQTETESTLSLKNPITSPVVTQKKVPDNCCRREPMLVRNNQKCDSVEEETGINRERKVEVIKPLVAETDTPNRATFVVGNSSLLDTSSVLVTQEPEIELPREPRPNEECLQILGNAEKGAKFLSDAEIIQLVNAKHIPAYKLETLMETHERGVSIRRQLLSKKLSEPSSLQYLPYRDYNYSLVMGACCENVIGYMPIPVGVAGPLCLDEKEFQVPMATTEGCLVASTNRGCRAIGLGGGASSRVLADGMTRGPVVRLPRACDSAEVKAWLETSEGFAVIKEAFDSTSRFARLQKLHTSIAGRNLYIRFQSRSGDAMGMNMISKGTEKALSKLHEYFPEMQILAVSGNYCTDKKPAAINWIEGRGKSVVCEAVIPAKVVREVLKTTTEAMIEVNINKNLVGSAMAGSIGGYNAHAANIVTAIYIACGQDAAQNVGSSNCITLMEASGPTNEDLYISCTMPSIEIGTVGGGTNLLPQQACLQMLGVQGACKDNPGENARQLARIVCGTVMAGELSLMAALAAGHLVKSHMIHNRSKINLQDLQGACTKKTA,hmdh,54
+MKTPWKVLLGLLGAAALVTIITVPVVLLNKGTDDATADSRKTYTLTDYLKNTYRLKLYSLRWISDHEYLYKQENNILVFNAEYGNSSVFLENSTFDEFGHSINDYSISPDGQFILLEYNYVKQWRHSYTASYDIYDLNKRQLITEERIPNNTQWVTWSPVGHKLAYVWNNDIYVKIEPNLPSYRITWTGKEDIIYNGITDWVYEEEVFSAYSALWWSPNGTFLAYAQFNDTEVPLIEYSFYSDESLQYPKTVRVPYPKAGAVNPTVKFFVVNTDSLSSVTNATSIQITAPASMLIGDHYLCDVTWATQERISLQWLRRIQNYSVMDICDYDESSGRWNCLVARQHIEMSTTGWVGRFRPSEPHFTLDGNSFYKIISNEEGYRHICYFQIDKKDCTFITKGTWEVIGIEALTSDYLYYISNEYKGMPGGRNLYKIQLSDYTKVTCLSCELNPERCQYYSVSFSKEAKYYQLRCSGPGLPLYTLHSSVNDKGLRVLEDNSALDKMLQNVQMPSKKLDFIILNETKFWYQMILPPHFDKSKKYPLLLDVYAGPCSQKADTVFRLNWATYLASTENIIVASFDGRGSGYQGDKIMHAINRRLGTFEVEDQIEAARQFSKMGFVDNKRIAIWGWSYGGYVTSMVLGSGSGVFKCGIAVAPVSRWEYYDSVYTERYMGLPTPEDNLDHYRNSTVMSRAENFKQVEYLLIHGTADDNVHFQQSAQISKALVDVGVDFQAMWYTDEDHGIASSTAHQHIYTHMSHFIKQCFSLP,dpp4,55
+MDSKESLTPGREENPSSVLAQERGDVMDFYKTLRGGATVKVSASSPSLAVASQSDSKQRRLLVDFPKGSVSNAQQPDLSKAVSLSMGLYMGETETKVMGNDLGFPQQGQISLSSGETDLKLLEESIANLNRSTSVPENPKSSASTAVSAAPTEKEFPKTHSDVSSEQQHLKGQTGTNGGNVKLYTTDQSTFDILQDLEFSSGSPGKETNESPWRSDLLIDENCLLSPLAGEDDSFLLEGNSNEDCKPLILPDTKPKIKDNGDLVLSSPSNVTLPQVKTEKEDFIELCTPGVIKQEKLGTVYCQASFPGANIIGNKMSAISVHGVSTSGGQMYHYDMNTASLSQQQDQKPIFNVIPPIPVGSENWNRCQGSGDDNLTSLGTLNFPGRTVFSNGYSSPSMRPDVSSPPSSSSTATTGPPPKLCLVCSDEASGCHYGVLTCGSCKVFFKRAVEGQHNYLCAGRNDCIIDKIRRKNCPACRYRKCLQAGMNLEARKTKKKIKGIQQATTGVSQETSENPGNKTIVPATLPQLTPTLVSLLEVIEPEVLYAGYDSSVPDSTWRIMTTLNMLGGRQVIAAVKWAKAIPGFRNLHLDDQMTLLQYSWMFLMAFALGWRSYRQSSANLLCFAPDLIINEQRMTLPCMYDQCKHMLYVSSELHRLQVSYEEYLCMKTLLLLSSVPKDGLKSQELFDEIRMTYIKELGKAIVKREGNSSQNWQRFYQLTKLLDSMHEVVENLLNYCFQTFLDKTMSIEFPEMLAEIITNQIPKYSNGNIKKLLFHQK,gcr,56
+MGETLGDSPIDPESDSFTDTLSANISQEMTMVDTEMPFWPTNFGISSVDLSVMEDHSHSFDIKPFTTVDFSSISTPHYEDIPFTRTDPVVADYKYDLKLQEYQSAIKVEPASPPYYSEKTQLYNKPHEEPSNSLMAIECRVCGDKASGFHYGVHACEGCKGFFRRTIRLKLIYDRCDLNCRIHKKSRNKCQYCRFQKCLAVGMSHNAIRFGRMPQAEKEKLLAEISSDIDQLNPESADLRALAKHLYDSYIKSFPLTKAKARAILTGKTTDKSPFVIYDMNSLMMGEDKIKFKHITPLQEQSKEVAIRIFQGCQFRSVEAVQEITEYAKSIPGFVNLDLNDQVTLLKYGVHEIIYTMLASLMNKDGVLISEGQGFMTREFLKSLRKPFGDFMEPKFEFAVKFNALELDDSDLAIFIAVIILSGDRPGLLNVKPIEDIQDNLLQALELQLKLNHPESSQLFAKLLQKMTDLRQIVTEHVQLLQVIKKTETDMSLHPLLQEIYKDLY,pparg,57
+MEFSSPSREECPKPLSRVSIMAGSLTGLLLLQAVSWASGARPCIPKSFGYSSVVCVCNATYCDSFDPPTFPALGTFSRYESTRSGRRMELSMGPIQANHTGTGLLLTLQPEQKFQKVKGFGGAMTDAAALNILALSPPAQNLLLKSYFSEEGIGYNIIRVPMASCDFSIRTYTYADTPDDFQLHNFSLPEEDTKLKIPLIHRALQLAQRPVSLLASPWTSPTWLKTNGAVNGKGSLKGQPGDIYHQTWARYFVKFLDAYAEHKLQFWAVTAENEPSAGLLSGYPFQCLGFTPEHQRDFIARDLGPTLANSTHHNVRLLMLDDQRLLLPHWAKVVLTDPEAAKYVHGIAVHWYLDFLAPAKATLGETHRLFPNTMLFASEACVGSKFWEQSVRLGSWDRGMQYSHSIITNLLYHVVGWTDWNLALNPEGGPNWVRNFVDSPIIVDITKDTFYKQPMFYHLGHFSKFIPEGSQRVGLVASQKNDLDAVALMHPDGSAVVVVLNRSSKDVPLTIKDPAVGFLETISPGYSIHTYLWRRQ,glcm,58
+MEDHMFGVQQIQPNVISVRLFKRKVGGLGFLVKERVSKPPVIISDLIRGGAAEQSGLIQAGDIILAVNGRPLVDLSYDSALEVLRGIASETHVVLILRGPEGFTTHLETTFTGDGTPKTIRVTQPLGPPTKAVDLSHQPPAGKEQPLAVDGASGPGNGPQHAYDDGQEAGSLPHANGLAPRPPGQDPAKKATRVSLQGRGENNELLKEIEPVLSLLTSGSRGVKGGAPAKAEMKDMGIQVDRDLDGKSHKPLPLGVENDRVFNDLWGKGNVPVVLNNPYSEKEQPPTSGKQSPTKNGSPSKCPRFLKVKNWETEVVLTDTLHLKSTLETGCTEYICMGSIMHPSQHARRPEDVRTKGQLFPLAKEFIDQYYSSIKRFGSKAHMERLEEVNKEIDTTSTYQLKDTELIYGAKHAWRNASRCVGRIQWSKLQVFDARDCTTAHGMFNYICNHVKYATNKGNLRSAITIFPQRTDGKHDFRVWNSQLIRYAGYKQPDGSTLGDPANVQFTEICIQQGWKPPRGRFDVLPLLLQANGNDPELFQIPPELVLEVPIRHPKFEWFKDLGLKWYGLPAVSNMLLEIGGLEFSACPFSGWYMGTEIGVRDYCDNSRYNILEEVAKKMNLDMRKTSSLWKDQALVEINIAVLYSFQSDKVTIVDHHSATESFIKHMENEYRCRGGCPADWVWIVPPMSGSITPVFHQEMLNYRLTPSFEYQPDPWNTHVWKGTNGTPTKRRAIGFKKLAEAVKFSAKLMGQAMAKRVKATILYATETGKSQAYAKTLCEIFKHAFDAKVMSMEEYDIVHLEHETLVLVVTSTFGNGDPPENGEKFGCALMEMRHPNSVQEERKSYKVRFNSVSSYSDSQKSSGDGPDLRDNFESAGPLANVRFSVFGLGSRAYPHFCAFGHAVDTLLEELGGERILKMREGDELCGQEEAFRTWAKKVFKAACDVFCVGDDVNIEKANNSLISNDRSWKRNKFRLTFVAEAPELTQGLSNVHKKRVSAARLLSRQNLQSPKSSRSTIFVRLHTNGSQELQYQPGDHLGVFPGNHEDLVNALIERLEDAPPVNQMVKVELLEERNTALGVISNWTDELRLPPCTIFQAFKYYLDITTPPTPLQLQQFASLATSEKEKQRLLVLSKGLQEYEEWKWGKNPTIVEVLEEFPSIQMPATLLLTQLSLLQPRYYSISSSPDMYPDEVHLTVAIVSYRTRDGEGPIHHGVCSSWLNRIQADELVPCFVRGAPSFHLPRNPQVPCILVGPGTGIAPFRSFWQQRQFDIQHKGMNPCPMVLVFGCRQSKIDHIYREETLQAKNKGVFRELYTAYSREPDKPKKYVQDILQEQLAESVYRALKEQGGHIYVCGDVTMAADVLKAIQRIMTQQGKLSAEDAGVFISRMRDDNRYHEDIFGVTLRTYEVTNRLRSESIAFIEESKKDTDEVFSS,nos1,59
+MDIKNSPSSLNSPSSYNCSQSILPLEHGSIYIPSSYVDSHHEYPAMTFYSPAVMNYSIPSNVTNLEGGPGRQTTSPNVLWPTPGHLSPLVVHRQLSHLYAEPQKSPWCEARSLEHTLPVNRETLKRKVSGNRCASPVTGPGSKRDAHFCAVCSDYASGYHYGVWSCEGCKAFFKRSIQGHNDYICPATNQCTIDKNRRKSCQACRLRKCYEVGMVKCGSRRERCGYRLVRRQRSADEQLHCAGKAKRSGGHAPRVRELLLDALSPEQLVLTLLEAEPPHVLISRPSAPFTEASMMMSLTKLADKELVHMISWAKKIPGFVELSLFDQVRLLESCWMEVLMMGLMWRSIDHPGKLIFAPDLVLDRDEGKCVEGILEIFDMLLATTSRFRELKLQHKEYLCVKAMILLNSSMYPLVTATQDADSSRKLAHLLNAVTDALVWVIAKSGISSQQQSMRLANLLMLLSHVRHASNKGMEHLLNMKCKNVVPVYDLLLEMLNAHVLRGCKSSITGSECSPAEDSKSKEGSQNPQSQ,esr2,60
+MSNKCDVVVVGGGISGMAAAKLLHDSGLNVVVLEARDRVGGRTYTLRNQKVKYVDLGGSYVGPTQNRILRLAKELGLETYKVNEVERLIHHVKGKSYPFRGPFPPVWNPITYLDHNNFWRTMDDMGREIPSDAPWKAPLAEEWDNMTMKELLDKLCWTESAKQLATLFVNLCVTAETHEVSALWFLWYVKQCGGTTRIISTTNGGQERKFVGGSGQVSERIMDLLGDRVKLERPVIYIDQTRENVLVETLNHEMYEAKYVISAIPPTLGMKIHFNPPLPMMRNQMITRVPLGSVIKCIVYYKEPFWRKKDYCGTMIIDGEEAPVAYTLDDTKPEGNYAAIMGFILAHKARKLARLTKEERLKKLCELYAKVLGSLEALEPVHYEEKNWCEEQYSGGCYTTYFPPGILTQYGRVLRQPVDRIYFAGTETATHWSGYMEGAVEAGERAAREILHAMGKIPEDEIWQSEPESVDVPAQPITTTFLERHLPSVPGLLRLIGLTTIFSATALGFLAHKRGLLVRV,aofb,61
+MNPNQKILCTSATALVIGTIAVLIGITNLGLNIGLHLKPSCNCSHSQPEATNASQTIINNYYNDTNITQISNTNIQVEERAIRDFNNLTKGLCTINSWHIYGKDNAVRIGEDSDVLVTREPYVSCDPDECRFYALSQGTTIRGKHSNGTIHDRSQYRALISWPLSSPPTVYNSRVECIGWSSTSCHDGKTRMSICISGPNNNASAVIWYNRRPVTEINTWARNILRTQESECVCHNGVCPVVFTDGSATGPAETRIYYFKEGKILKWEPLAGTAKHIEECSCYGERAEITCTCRDNWQGSNRPVIRIDPVAMTHTSQYICSPVLTDNPRPNDPTVGKCNDPYPGNNNNGVKGFSYLDGVNTWLGRTISIASRSGYEMLKVPNALTDDKSKPTQGQTIVLNTDWSGYSGSFMDYWAEGECYRACFYVELIRGRPKEDKVWWTSNSIVSMCSSTEFLGQWDWPDGAKIEYFL,nram,62
+MLARALLLCAVLALSHTANPCCSHPCQNRGVCMSVGFDQYKCDCTRTGFYGENCSTPEFLTRIKLFLKPTPNTVHYILTHFKGFWNVVNNIPFLRNAIMSYVLTSRSHLIDSPPTYNADYGYKSWEAFSNLSYYTRALPPVPDDCPTPLGVKGKKQLPDSNEIVEKLLLRRKFIPDPQGSNMMFAFFAQHFTHQFFKTDHKRGPAFTNGLGHGVDLNHIYGETLARQRKLRLFKDGKMKYQIIDGEMYPPTVKDTQAEMIYPPQVPEHLRFAVGQEVFGLVPGLMMYATIWLREHNRVCDVLKQEHPEWGDEQLFQTSRLILIGETIKIVIEDYVQHLSGYHFKLKFDPELLFNKQFQYQNRIAAEFNTLYHWHPLLPDTFQIHDQKYNYQQFIYNNSILLEHGITQFVESFTRQIAGRVAGGRNVPPAVQKVSQASIDQSRQMKYQSFNEYRKRFMLKPYESFEELTGEKEMSAELEALYGDIDAVELYPALLVEKPRPDAIFGETMVEVGAPFSLKGLMGNVICSPAYWKPSTFGGEVGFQIINTASIQSLICNNVKGCPFTSFSVPDPELIKTVTINASSSRSGLDDINPTVLLKERSTEL,pgh2,63
+MAAAAAAGAGPEMVRGQVFDVGPRYTNLSYIGEGAYGMVCSAYDNVNKVRVAIKKISPFEHQTYCQRTLREIKILLRFRHENIIGINDIIRAPTIEQMKDVYIVQDLMETDLYKLLKTQHLSNDHICYFLYQILRGLKYIHSANVLHRDLKPSNLLLNTTCDLKICDFGLARVADPDHDHTGFLTEYVATRWYRAPEIMLNSKGYTKSIDIWSVGCILAEMLSNRPIFPGKHYLDQLNHILGILGSPSQEDLNCIINLKARNYLLSLPHKNKVPWNRLFPNADSKALDLLDKMLTFNPHKRIEVEQALAHPYLEQYYDPSDEPIAEAPFKFDMELDDLPKEKLKELIFEETARFQPGYRS,mk01,64
+MSTGDSFETRFEKMDNLLRDPKSEVNSDCLLDGLDALVYDLDFPALRKNKNIDNFLSRYKDTINKIRDLRMKAEDYEVVKVIGRGAFGEVQLVRHKSTRKVYAMKLLSKFEMIKRSDSAFFWEERDIMAFANSPWVVQLFYAFQDDRYLYMVMEYMPGGDLVNLMSNYDVPEKWARFYTAEVVLALDAIHSMGFIHRDVKPDNMLLDKSGHLKLADFGTCMKMNKEGMVRCDTAVGTPDYISPEVLKSQGGDGYYGRECDWWSVGVFLYEMLVGDTPFYADSLVGTYSKIMNHKNSLTFPDDNDISKEAKNLICAFLTDREVRLGRNGVEEIKRHLFFKNDQWAWETLRDTVAPVVPDLSSDIDTSNFDDLEEDKGEEETFPIPKAFVGNQLPFVGFTYYSNRRYLSSANPNDNRTSSNADKSLQESLQKTIYKLEEQLHNEMQLKDEMEQKCRTSNIKLDKIMKELDEEGNQRRNLESTVSQIEKEKMLLQHRINEYQRKAEQENEKRRNVENEVSTLKDQLEDLKKVSQNSQLANEKLSQLQKQLEEANDLLRTESDTAVRLRKSHTEMSKSISQLESLNRELQERNRILENSKSQTDKDYYQLQAILEAERRDRGHDSEMIGDLQARITSLQEEVKHLKHNLEKVEGERKEAQDMLNHSEKEKNNLEIDLNYKLKSLQQRLEQEVNEHKVTKARLTDKHQSIEEAKSVAMCEMEKKLKEEREAREKAENRVVQIEKQCSMLDVDLKQSQQKLEHLTGNKERMEDEVKNLTLQLEQESNKRLLLQNELKTQAFEADNLKGLEKQMKQEINTLLEAKRLLEFELAQLTKQYRGNEGQMRELQDQLEAEQYFSTLYKTQVKELKEEIEEKNRENLKKIQELQNEKETLATQLDLAETKAESEQLARGLLEEQYFELTQESKKAASRNRQEITDKDHTVSRLEEANSMLTKDIEILRRENEELTEKMKKAEEEYKLEKEEEISNLKAAFEKNINTERTLKTQAVNKLAEIMNRKDFKIDRKKANTQDLRKKEKENRKLQLELNQEREKFNQMVVKHQKELNDMQAQLVEECAHRNELQMQLASKESDIEQLRAKLLDLSDSTSVASFPSADETDGNLPESRIEGWLSVPNRGNIKRYGWKKQYVVVSSKKILFYNDEQDKEQSNPSMVLDIDKLFHVRPVTQGDVYRAETEEIPKIFQILYANEGECRKDVEMEPVQQAEKTNFQNHKGHEFIPTLYHFPANCDACAKPLWHVFKPPPALECRRCHVKCHRDHLDKKEDLICPCKVSYDVTSARDMLLLACSQDEQKKWVTHLVKKIPKNPPSGFVRASPRTLSTRSTANQSFRKVVKNTSGKTS,rock1,65
+MGVQVETISPGDGRTFPKRGQTCVVHYTGMLEDGKKFDSSRDRNKPFKFMLGKQEVIRGWEEGVAQMSVGQRAKLTISPDYAYGATGHPGIIPPHATLVFDVELLKLE,fkb1a,66
+MENTENSVDSKSIKNLEPKIIHGSESMDSGISLDNSYKMDYPEMGLCIIINNKNFHKSTGMTSRSGTDVDAANLRETFRNLKYEVRNKNDLTREEIVELMRDVSKEDHSKRSSFVCVLLSHGEEGIIFGTNGPVDLKKITNFFRGDRCRSLTGKPKLFIIQACRGTELDCGIETDSGVDDDMACHKIPVEADFLYAYSTAPGYYSWRNSKDGSWFIQSLCAMLKQYADKLEFMHILTRVNRKVATEFESFSFDATFHAKKQIPCIVSMLTKELYFYH,casp3,67
+MSQERPTFYRQELNKTIWEVPERYQNLSPVGSGAYGSVCAAFDTKTGLRVAVKKLSRPFQSIIHAKRTYRELRLLKHMKHENVIGLLDVFTPARSLEEFNDVYLVTHLMGADLNNIVKCQKLTDDHVQFLIYQILRGLKYIHSADIIHRDLKPSNLAVNEDCELKILDFGLARHTDDEMTGYVATRWYRAPEIMLNWMHYNQTVDIWSVGCIMAELLTGRTLFPGTDHIDQLKLILRLVGTPGAELLKKISSESARNYIQSLTQMPKMNFANVFIGANPLAVDLLEKMLVLDSDKRITAAQALAHAYFAQYHDPDDEPVADPYDQSFESRDLLIDEWKSLTYDEVISFVPPPLDQEEMES,mk14,68
+MSFLSRQQPPPPRRAGAACTLRQKLIFSPCSDCEEEEEEEEEEGSGHSTGEDSAFQEPDSPLPPARSPTEPGPERRRSPGPAPGSPGELEEDLLLPGACPGADEAGGGAEGDSWEEEGFGSSSPVKSPAAPYFLGSSFSPVRCGGPGDASPRGCGARRAGEGRRSPRPDHPGTPPHKTFRKLRLFDTPHTPKSLLSKARGIDSSSVKLRGSSLFMDTEKSGKREFDVRQTPQVNINPFTPDSLLLHSSGQCRRRKRTYWNDSCGEDMEASDYELEDETRPAKRITITESNMKSRYTTEFHELEKIGSGEFGSVFKCVKRLDGCIYAIKRSKKPLAGSVDEQNALREVYAHAVLGQHSHVVRYFSAWAEDDHMLIQNEYCNGGSLADAISENYRIMSYFKEAELKDLLLQVGRGLRYIHSMSLVHMDIKPSNIFISRTSIPNAASEEGDEDDWASNKVMFKIGDLGHVTRISSPQVEEGDSRFLANEVLQENYTHLPKADIFALALTVVCAAGAEPLPRNGDQWHEIRQGRLPRIPQVLSQEFTELLKVMIHPDPERRPSAMALVKHSVLLSASRKSAEQLRIELNAEKFKNSLLQKELKKAQMAKAAAEERALFTDRMATRSTTQSNRTSRLIGKKMNRSVSLTIY,wee1,69
+MAAAYLDPNLNHTPNSSTKTHLGTGMERSPGAMERVLKVFHYFESNSEPTTWASIIRHGDATDVRGIIQKIVDSHKVKHVACYGFRLSHLRSEEVHWLHVDMGVSSVREKYELAHPPEEWKYELRIRYLPKGFLNQFTEDKPTLNFFYQQVKSDYMLEIADQVDQEIALKLGCLEIRRSYWEMRGNALEKKSNYEVLEKDVGLKRFFPKSLLDSVKAKTLRKLIQQTFRQFANLNREESILKFFEILSPVYRFDKECFKCALGSSWIISVELAIGPEEGISYLTDKGCNPTHLADFTQVQTIQYSNSEDKDRKGMLQLKIAGAPEPLTVTAPSLTIAENMADLIDGYCRLVNGTSQSFIIRPQKEGERALPSIPKLANSEKQGMRTHAVSVSETDDYAEIIDEEDTYTMPSTRDYEIQRERIELGRCIGEGQFGDVHQGIYMSPENPALAVAIKTCKNCTSDSVREKFLQEALTMRQFDHPHIVKLIGVITENPVWIIMELCTLGELRSFLQVRKYSLDLASLILYAYQLSTALAYLESKRFVHRDIAARNVLVSSNDCVKLGDFGLSRYMEDSTYYKASKGKLPIKWMAPESINFRRFTSASDVWMFGVCMWEILMHGVKPFQGVKNNDVIGRIENGERLPMPPNCPPTLYSLMTKCWAYDPSRRPRFTELKAQLSTILEEEKAQQEERMRMESRRQATVSWDSGGSDEAPPKPSRPGYPSPRSSEGFYPSPQHMVQTNHYQVSGYPGSHGITAMAGSIYPGQASLLDQTDSWNHRPQEIAMWQPNVEDSTVLDLRGIGQVLPTHLMEERLIRQQQEMEEDQRWLEKEERFLKPDVRLSRGSIDREDGSLQGPIGNQHIYQPVGKPDPAAPPKKPPRPGAPGHLGSLASLSSPADSYNEGVKLQPQEISPPPTANLDRSNDKVYENVTGLVKAVIEMSSKIQPAPPEEYVPMVKEVGLALRTLLATVDETIPLLPASTHREIEMAQKLLNSDLGELINKMKLAQQYVMTSLQQEYKKQMLTAAHALAVDAKNLLDVIDQARLKMLGQTRPH,fak1,70
+MHPGVLAAFLFLSWTHCRALPLPSGGDEDDLSEEDLQFAERYLRSYYHPTNLAGILKENAASSMTERLREMQSFFGLEVTGKLDDNTLDVMKKPRCGVPDVGEYNVFPRTLKWSKMNLTYRIVNYTPDMTHSEVEKAFKKAFKVWSDVTPLNFTRLHDGIADIMISFGIKEHGDFYPFDGPSGLLAHAFPPGPNYGGDAHFDDDETWTSSSKGYNLFLVAAHEFGHSLGLDHSKDPGALMFPIYTYTGKSHFMLPDDDVQGIQSLYGPGDEDPNPKHPKTPDKCDPSLSLDAITSLRGETMIFKDRFFWRLHPQQVDAELFLTKSFWPELPNRIDAAYEHPSHDLIFIFRGRKFWALNGYDILEGYPKKISELGLPKEVKKISAAVHFEDTGKTLLFSGNQVWRYDDTNHIMDKDYPRLIEEDFPGIGDKVDAVYEKNGYIYFFNGPIQFEYSIWSNRIVRVMPANSILWC,mmp13,71
+PISPIEPVPVKLKPGMDGPKVKQWPLTEEKIKALVEICTEMEKEGKISKIGPENPYNTPVFAIKKKDSTRWRKLVDFRELNKRTQDFWEVQLGIPHPAGLKKKRSVTVLDVGDAYFSVPLDKEFRKYTAFTIPSINNETPGIRYQYNVLPQGWKGSPAIFQSSMTKILEPFRKQNPDIVIYQYMDDLYVGSDLEIGQHRTKIEELRQHLLKWGFTTPDKKHQKEPPFLWMGYEHHPDKWTVQPIVLPEKDSWTVNDIQK,hivrt,72
+MASRLLLNNGAKMPILGLGTWKSPPGQVTEAVKVAIDVGYRHIDCAHVYQNENEVGVAIQEKLREQVVKREELFIVSKLWCTYHEKGLVKGACQKTLSDLKLDYLDLYLIHWPTGFKPGKEFFPLDESGNVVPSDTNILDTWAAMEELVDEGLVKAIGISNFNHLQVEMILNKPGLKYKPAVNQIECHPYLTQEKLIQYCQSKGIVVTAYSPLGSPDRPWAKPEDPSLLEDPRIKAIAAKHNKTTAQVLIRFPMQRNLVVIPKSVTPERIAENFKVFDFELSSQDMTTLLSYNRNWRVCALLSCTSHKDYPFHEEF,aldr,73
+MVGSLNCIVAVSQNMGIGKNGDLPWPPLRNEFRYFQRMTTTSSVEGKQNLVIMGKKTWFSIPEKNRPLKGRINLVLSRELKEPPQGAHFLSRSLDDALKLTEQPELANKVDMVWIVGGSSVYKEAMNHPGHLKLFVTRIMQDFESDTFFPEIDLEKYKLLPEYPGVLSDVQEEKGIKYKFEVYEKND,dyr,74
+MEMEKEFEQIDKSGSWAAIYQDIRHEASDFPCRVAKLPKNKNRNRYRDVSPFDHSRIKLHQEDNDYINASLIKMEEAQRSYILTQGPLPNTCGHFWEMVWEQKSRGVVMLNRVMEKGSLKCAQYWPQKEEKEMIFEDTNLKLTLISEDIKSYYTVRQLELENLTTQETREILHFHYTTWPDFGVPESPASFLNFLFKVRESGSLSPEHGPVVVHCSAGIGRSGTFCLADTCLLLMDKRKDPSSVDIKKVLLEMRKFRMGLIQTADQLRFSYLAVIEGAKFIMGDSSVQDQWKELSHEDLEPPPEHIPPPPRPPKRILEPHNGKCREFFPNHQWVKEETQEDKDCPIKEEKGSPLNAAPYGIESMSQDTEVRSRVVGGSLRGAQAASPAKGEPSLPEKDEDHALSYWKPFLVNMCVATVLTAGAYLCYRFLFNSNT,ptn1,75
+MAQTPAFDKPKVELHVHLDGSIKPETILYYGRRRGIALPANTAEGLLNVIGMDKPLTLPDFLAKFDYYMPAIAGCREAIKRIAYEFVEMKAKEGVVYVEVRYSPHLLANSKVEPIPWNQAEGDLTPDEVVALVGQGLQEGERDFGVKARSILCCMRHQPNWSPKVVELCKKYQQQTVVAIDLAGDETIPGSSLLPGHVQAYQEAVKSGIHRTVHAGEVGSAEVVKEAVDILKTERLGHGYHTLEDQALYNRLRQENMHFEICPWSSYLTGAWKPDTEHAVIRLKNDQANYSLNTDDPLIFKSTLDTDYQMTKRDMGFTEEEFKRLNINAAKSSFLPEDEKRELLDLLYKAYGMPPSASAGQNL,ada,76
+MGCGCSSHPEDDWMENIDVCENCHYPIVPLDGKGTLLIRNGSEVRDPLVTYEGSNPPASPLQDNLVIALHSYEPSHDGDLGFEKGEQLRILEQSGEWWKAQSLTTGQEGFIPFNFVAKANSLEPEPWFFKNLSRKDAERQLLAPGNTHGSFLIRESESTAGSFSLSVRDFDQNQGEVVKHYKIRNLDNGGFYISPRITFPGLHELVRHYTNASDGLCTRLSRPCQTQKPQKPWWEDEWEVPRETLKLVERLGAGQFGEVWMGYYNGHTKVAVKSLKQGSMSPDAFLAEANLMKQLQHQRLVRLYAVVTQEPIYIITEYMENGSLVDFLKTPSGIKLTINKLLDMAAQIAEGMAFIEERNYIHRDLRAANILVSDTLSCKIADFGLARLIEDNEYTAREGAKFPIKWTAPEAINYGTFTIKSDVWSFGILLTEIVTHGRIPYPGMTNPEVIQNLERGYRMVRPDNCPEELYQLMRLCWKERPEDRPTFDYLRSVLEDFFTATEGQYQPQP,lck,77
+MGRPLHLVLLSASLAGLLLLGESLFIRREQANNILARVTRANSFLEEMKKGHLERECMEETCSYEEAREVFEDSDKTNEFWNKYKDGDQCETSPCQNQGKCKDGLGEYTCTCLEGFEGKNCELFTRKLCSLDNGDCDQFCHEEQNSVVCSCARGYTLADNGKACIPTGPYPCGKQTLERRKRSVAQATSSSGEAPDSITWKPYDAADLDPTENPFDLLDFNQTQPERGDNNLTRIVGGQECKDGECPWQALLINEENEGFCGGTILSEFYILTAAHCLYQAKRFKVRVGDRNTEQEEGGEAVHEVEVVIKHNRFTKETYDFDIAVLRLKTPITFRMNVAPACLPERDWAESTLMTQKTGIVSGFGRTHEKGRQSTRLKMLEVPYVDRNSCKLSSSFIITQNMFCAGYDTKQEDACQGDSGGPHVTRFKDTYFVTGIVSWGEGCARKGKYGIYTKVTAFLKWIDRSMKTRGLPKAKSHAPEVITSSPLK,fa10,78
+MNEVSVIKEGWLHKRGEYIKTWRPRYFLLKSDGSFIGYKERPEAPDQTLPPLNNFSVAECQLMKTERPRPNTFVIRCLQWTTVIERTFHVDSPDEREEWMRAIQMVANSLKQRAPGEDPMDYKCGSPSDSSTTEEMEVAVSKARAKVTMNDFDYLKLLGKGTFGKVILVREKATGRYYAMKILRKEVIIAKDEVAHTVTESRVLQNTRHPFLTALKYAFQTHDRLCFVMEYANGGELFFHLSRERVFTEERARFYGAEIVSALEYLHSRDVVYRDIKLENLMLDKDGHIKITDFGLCKEGISDGATMKTFCGTPEYLAPEVLEDNDYGRAVDWWGLGVVMYEMMCGRLPFYNQDHERLFELILMEEIRFPRTLSPEAKSLLAGLLKKDPKQRLGGGPSDAKEVMEHRFFLSINWQDVVQKKLLPPFKPQVTSEVDTRYFDDEFTAQSITITPPDRYDSLGLLELDQRTHFPQFSYSASIRE,akt2,79
+MESKALLAVALWFCVETRAASVGLPGDFLHPPKLSTQKDILTILANTTLQITCRGQRDLDWLWPNAQRDSEERVLVTECGGGDSIFCKTLTIPRVVGNDTGAYKCSYRDVDIASTVYVYVRDYRSPFIASVSDQHGIVYITENKNKTVVIPCRGSISNLNVSLCARYPEKRFVPDGNRISWDSEIGFTLPSYMISYAGMVFCEAKINDETYQSIMYIVVVVGYRIYDVILSPPHEIELSAGEKLVLNCTARTELNVGLDFTWHSPPSKSHHKKIVNRDVKPFPGTVAKMFLSTLTIESVTKSDQGEYTCVASSGRMIKRNRTFVRVHTKPFIAFGSGMKSLVEATVGSQVRIPVKYLSYPAPDIKWYRNGRPIESNYTMIVGDELTIMEVTERDAGNYTVILTNPISMEKQSHMVSLVVNVPPQIGEKALISPMDSYQYGTMQTLTCTVYANPPLHHIQWYWQLEEACSYRPGQTSPYACKEWRHVEDFQGGNKIEVTKNQYALIEGKNKTVSTLVIQAANVSALYKCEAINKAGRGERVISFHVIRGPEITVQPAAQPTEQESVSLLCTADRNTFENLTWYKLGSQATSVHMGESLTPVCKNLDALWKLNGTMFSNSTNDILIVAFQNASLQDQGDYVCSAQDKKTKKRHCLVKQLIILERMAPMITGNLENQTTTIGETIEVTCPASGNPTPHITWFKDNETLVEDSGIVLRDGNRNLTIRRVRKEDGGLYTCQACNVLGCARAETLFIIEGAQEKTNLEVIILVGTAVIAMFFWLLLVILVRTVKRANEGELKTGYLSIVMDPDELPLDERCERLPYDASKWEFPRDRLKLGKPLGRGAFGQVIEADAFGIDKTATCKTVAVKMLKEGATHSEHRALMSELKILIHIGHHLNVVNLLGACTKPGGPLMVIVEFSKFGNLSTYLRGKRNEFVPYKSKGARFRQGKDYVGELSVDLKRRLDSITSSQSSASSGFVEEKSLSDVEEEEASEELYKDFLTLEHLICYSFQVAKGMEFLASRKCIHRDLAARNILLSEKNVVKICDFGLARDIYKDPDYVRKGDARLPLKWMAPETIFDRVYTIQSDVWSFGVLLWEIFSLGASPYPGVKIDEEFCRRLKEGTRMRAPDYTTPEMYQTMLDCWHEDPNQRPSFSELVEHLGNLLQANAQQDGKDYIVLPMSETLSMEEDSGLSLPTSPVSCMEEEEVCDPKFHYDNTAGISHYLQNSKRKSRPVSVKTFEDIPLEEPEVKVIPDDSQTDSGMVLASEELKTLEDRNKLSPSFGGMMPSKSRESVASEGSNQTSGYQSGYHSDDTDTTVYSSDEAGLLKMVDAAVHADSGTTLQLTSCLNGSGPVPAPPPTPGNHERGAA,vgfr2,80
+MFKTTLCALLITASCSTFAAPQQINDIVHRTITPLIEQQKIPGMAVAVIYQGKPYYFTWGYADIAKKQPVTQQTLFELGSVSKTFTGVLGGDAIARGEIKLSDPTTKYWPELTAKQWNGITLLHLATYTAGGLPLQVPDEVKSSSDLLRFYQNWQPAWAPGTQRLYANSSIGLFGALAVKPSGLSFEQAMQTRVFQPLKLNHTWINVPPAEEKNYAWGYREGKAVHVSPGALDAEAYGVKSTIEDMARWVQSNLKPLDINEKTLQQGIQLAQSRYWQTGDMYQGLGWEMLDWPVNPDSIINGSDNKIALAARPVKAITPPTPAVRASWVHKTGATGGFGSYVAFIPEKELGIVMLANKNYPNPARVDAAWQILNALQ,ampc,81
+MAFMKKYLLPILGLFMAYYYYSANEEFRPEMLQGKKVIVTGASKGIGREMAYHLAKMGAHVVVTARSKETLQKVVSHCLELGAASAHYIAGTMEDMTFAEQFVAQAGKLMGGLDMLILNHITNTSLNLFHDDIHHVRKSMEVNFLSYVVLTVAALPMLKQSNGSIVVVSSLAGKVAYPMVAAYSASKFALDGFFSSIRKEYSVSRVNVSITLCVLGLIDTETAMKAVSGIVHMQAAPKEECALEIIKGGALRQEEVYYDSSLWTTLLIRNPCRKILEFLYSTSYNMDRFINK,dhi1,82
+MASLSQLSSHLNYTCGAENSTGASQARPHAYYALSYCALILAIVFGNGLVCMAVLKERALQTTTNYLVVSLAVADLLVATLVMPWVVYLEVTGGVWNFSRICCDVFVTLDVMMCTASILNLCAISIDRYTAVVMPVHYQHGTGQSSCRRVALMITAVWVLAFAVSCPLLFGFNTTGDPTVCSISNPDFVIYSSVVSFYLPFGVTVLVYARIYVVLKQRRRKRILTRQNSQCNSVRPGFPQQTLSPDPAHLELKRYYSICQDTALGGPGFQERGGELKREEKTRNSLSPTIAPKLSLEVRKLSNGRLSTSLKLGPLQPRGVPLREKKATQMVAIVLGAFIVCWLPFFLTHVLNTHCQTCHVSPELYSATTWLGYVNSALNPVIYTTFNIEFRKAFLKILSC,drd3,83
+MGAGVLVLGASEPGNLSSAAPLPDGAATAARLLVPASPPASLLPPASESPEPLSQQWTAGMGLLMALIVLLIVAGNVLVIVAIAKTPRLQTLTNLFIMSLASADLVMGLLVVPFGATIVVWGRWEYGSFFCELWTSVDVLCVTASIETLCVIALDRYLAITSPFRYQSLLTRARARGLVCTVWAISALVSFLPILMHWWRAESDEARRCYNDPKCCDFVTNRAYAIASSVVSFYVPLCIMAFVYLRVFREAQKQVKKIDSCERRFLGGPARPPSPSPSPVPAPAPPPGPPRPAAAAATAPLANGRAGKRRPSRLVALREQKALKTLGIIMGVFTLCWLPFFLANVVKAFHRELVPDRLFVFFNWLGYANSAFNPIIYCRSPDFRKAFQRLLCCARRAARRRHATHGDRPRASGCLARPGPPPSPGAASDDDDDDVVGATPPARLLEPWAGCNGGAAADSDSSLDEPCRPGFASESKV,adrb1,84
+MQKIMHISVLLSPVLWGLIFGVSSNSIQIGGLFPRGADQEYSAFRVGMVQFSTSEFRLTPHIDNLEVANSFAVTNAFCSQFSRGVYAIFGFYDKKSVNTITSFCGTLHVSFITPSFPTDGTHPFVIQMRPDLKGALLSLIEYYQWDKFAYLYDSDRGLSTLQAVLDSAAEKKWQVTAINVGNINNDKKDEMYRSLFQDLELKKERRVILDCERDKVNDIVDQVITIGKHVKGYHYIIANLGFTDGDLLKIQFGGANVSGFQIVDYDDSLVSKFIERWSTLEEKEYPGAHTTTIKYTSALTYDAVQVMTEAFRNLRKQRIEISRRGNAGDCLANPAVPWGQGVEIERALKQVQVEGLSGNIKFDQNGKRINYTINIMELKTNGPRKIGYWSEVDKMVVTLTELPSGNDTSGLENKTVVVTTILESPYVMMKKNHEMLEGNERYEGYCVDLAAEIAKHCGFKYKLTIVGDGKYGARDADTKIWNGMVGELVYGKADIAIAPLTITLVREEVIDFSKPFMSLGISIMIKKPQKSKPGVFSFLDPLAYEIWMCIVFAYIGVSVVLFLVSRFSPYEWHTEEFEDGRETQSSESTNEFGIFNSLWFSLGAFMQQGCDISPRSLSGRIVGGVWWFFTLIIISSYTANLAAFLTVERMVSPIESAEDLSKQTEIAYGTLDSGSTKEFFRRSKIAVFDKMWTYMRSAEPSVFVRTTAEGVARVRKSKGKYAYLLESTMNEYIEQRKPCDTMKVGGNLDSKGYGIATPKGSSLRNAVNLAVLKLNEQGLLDKLKNKWWYDKGECGSGGGDSKEKTSALSLSNVAGVFYILVGGLGLAMLVALIEFCYKSRAEAKRMKVAKNAQNINPSSSQNSQNFATYKEGYNVYGIESVKI,gria2,85
+MLNLLLLALPVLASRAYAAPAPGQALQRVGIVGGQEAPRSKWPWQVSLRVHGPYWMHFCGGSLIHPQWVLTAAHCVGPDVKDLAALRVQLREQHLYYQDQLLPVSRIIVHPQFYTAQIGADIALLELEEPVNVSSHVHTVTLPPASETFPPGMPCWVTGWGDVDNDERLPPPFPLKQVKVPIMENHICDAKYHLGAYTGDDVRIVRDDMLCAGNTRRDSCQGDSGGPLVCKVNGTWLQAGVVSWGEGCAQPNRPGIYTRVTYYLDWIHHYVPKKP,tryb1,86
+MAARVLIIGSGGREHTLAWKLAQSHHVKQVLVAPGNAGTACSEKISNTAISISDHTALAQFCKEKKIEFVVVGPEAPLAAGIVGNLRSAGVQCFGPTAEAAQLESSKRFAKEFMDRHGIPTAQWKAFTKPEEACSFILSADFPALVVKASGLAAGKGVIVAKSKEEACKAVQEIMQEKAFGAAGETIVIEELLDGEEVSCLCFTDGKTVAPMPPAQDHKRLLEGDGGPNTGGMGAYCPAPQVSNDLLLKIKDTVLQRTVDGMQQEGTPYTGILYAGIMLTKNGPKVLEFNCRFGDPECQVILPLLKSDLYEVIQSTLDGLLCTSLPVWLENHTALTVVMASKGYPGDYTKGVEITGFPEAQALGLEVFHAGTALKNGKVVTHGGRVLAVTAIRENLISALEEAKKGLAAIKFEGAIYRKDVGFRAIAFLQQPRSLTYKESGVDIAAGNMLVKKIQPLAKATSRSGCKVDLGGFAGLFDLKAAGFKDPLLASGTDGVGTKLKIAQLCNKHDTIGQDLVAMCVNDILAQGAEPLFFLDYFSCGKLDLSVTEAVVAGIAKACGKAGCALLGGETAEMPDMYPPGEYDLAGFAVGAMERDQKLPHLERITEGDVVVGIASSGLHSNGFSLVRKIVAKSSLQYSSPAPDGCGDQTLGDLLLTPTRIYSHSLLPVLRSGHVKAFAHITGGGLLENIPRVLPEKLGVDLDAQTWRIPRVFSWLQQEGHLSEEEMARTFNCGVGAVLVVSKEQTEQILRDIQQHKEEAWVIGSVVARAEGSPRVKVKNLIESMQINGSVLKNGSLTNHFSFEKKKARVAVLISGTGSNLQALIDSTREPNSSAQIDIVISNKAAVAGLDKAERAGIPTRVINHKLYKNRVEFDSAIDLVLEEFSIDIVCLAGFMRILSGPFVQKWNGKMLNIHPSLLPSFKGSNAHEQALETGVTVTGCTVHFVAEDVDAGQIILQEAVPVKRGDTVATLSERVKLAEHKIFPAALQLVASGTVQLGENGKICWVKEE,pur2,87
+MGPGVLLLLLVATAWHGQGIPVIEPSVPELVVKPGATVTLRCVGNGSVEWDGPPSPHWTLYSDGSSSILSTNNATFQNTGTYRCTEPGDPLGGSAAIHLYVKDPARPWNVLAQEVVVFEDQDALLPCLLTDPVLEAGVSLVRVRGRPLMRHTNYSFSPWHGFTIHRAKFIQSQDYQCSALMGGRKVMSISIRLKVQKVIPGPPALTLVPAELVRIRGEAAQIVCSASSVDVNFDVFLQHNNTKLAIPQQSDFHNNRYQKVLTLNLDQVDFQHAGNYSCVASNVQGKHSTSMFFRVVESAYLNLSSEQNLIQEVTVGEGLNLKVMVEAYPGLQGFNWTYLGPFSDHQPEPKLANATTKDTYRHTFTLSLPRLKPSEAGRYSFLARNPGGWRALTFELTLRYPPEVSVIWTFINGSGTLLCAASGYPQPNVTWLQCSGHTDRCDEAQVLQVWDDPYPEVLSQEPFHKVTVQSLLTVETLEHNQTYECRAHNSVGSGSWAFIPISAGAHTHPPDEFLFTPVVVACMSIMALLLLLLLLLLYKYKQKPKYQVRWKIIESYEGNSYTFIDPTQLPYNEKWEFPRNNLQFGKTLGAGAFGKVVEATAFGLGKEDAVLKVAVKMLKSTAHADEKEALMSELKIMSHLGQHENIVNLLGACTHGGPVLVITEYCCYGDLLNFLRRKAEAMLGPSLSPGQDPEGGVDYKNIHLEKKYVRRDSGFSSQGVDTYVEMRPVSTSSNDSFSEQDLDKEDGRPLELRDLLHFSSQVAQGMAFLASKNCIHRDVAARNVLLTNGHVAKIGDFGLARDIMNDSNYIVKGNARLPVKWMAPESIFDCVYTVQSDVWSYGILLWEIFSLGLNPYPGILVNSKFYKLVKDGYQMAQPAFAPKNIYSIMQACWALEPTHRPTFQQICSFLQEQAQEDRRERDYTNLPSSSRSGGSGSSSSELEEESSSEHLTCCEQGDIAQPLLQPNNYQFC,csf1r,88
+MASQPNSSAKKKEEKGKNIQVVVRCRPFNLAERKASAHSIVECDPVRKEVSVRTGGLADKSSRKTYTFDMVFGASTKQIDVYRSVVCPILDEVIMGYNCTIFAYGQTGTGKTFTMEGERSPNEEYTWEEDPLAGIIPRTLHQIFEKLTDNGTEFSVKVSLLEIYNEELFDLLNPSSDVSERLQMFDDPRNKRGVIIKGLEEITVHNKDEVYQILEKGAAKRTTAATLMNAYSSRSHSVFSVTIHMKETTIDGEELVKIGKLNLVDLAGSENIGRSGAVDKRAREAGNINQSLLTLGRVITALVERTPHVPYRESKLTRILQDSLGGRTRTSIIATISPASLNLEETLSTLEYAHRAKNILNKPEVNQKLTKKALIKEYTEEIERLKRDLAAAREKNGVYISEENFRVMSGKLTVQEEQIVELIEKIGAVEEELNRVTELFMDNKNELDQCKSDLQNKTQELETTQKHLQETKLQLVKEEYITSALESTEEKLHDAASKLLNTVEETTKDVSGLHSKLDRKKAVDQHNAEAQDIFGKNLNSLFNNMEELIKDGSSKQKAMLEVHKTLFGNLLSSSVSALDTITTVALGSLTSIPENVSTHVSQIFNMILKEQSLAAESKTVLQELINVLKTDLLSSLEMILSPTVVSILKINSQLKHIFKTSLTVADKIEDQKKELDGFLSILCNNLHELQENTICSLVESQKQCGNLTEDLKTIKQTHSQELCKLMNLWTERFCALEEKCENIQKPLSSVQENIQQKSKDIVNKMTFHSQKFCADSDGFSQELRNFNQEGTKLVEESVKHSDKLNGNLEKISQETEQRCESLNTRTVYFSEQWVSSLNEREQELHNLLEVVSQCCEASSSDITEKSDGRKAAHEKQHNIFLDQMTIDEDKLIAQNLELNETIKIGLTKLNCFLEQDLKLDIPTGTTPQRKSYLYPSTLVRTEPREHLLDQLKRKQPELLMMLNCSENNKEETIPDVDVEEAVLGQYTEEPLSQEPSVDAGVDCSSIGGVPFFQHKKSHGKDKENRGINTLERSKVEETTEHLVTKSRLPLRAQINL,kif11,89
+MGQPGNGSAFLLAPNGSHAPDHDVTQERDEVWVVGMGIVMSLIVLAIVFGNVLVITAIAKFERLQTVTNYFITSLACADLVMGLAVVPFGAAHILMKMWTFGNFWCEFWTSIDVLCVTASIETLCVIAVDRYFAITSPFKYQSLLTKNKARVIILMVWIVSGLTSFLPIQMHWYRATHQEAINCYANETCCDFFTNQAYAIASSIVSFYVPLVIMVFVYSRVFQEAKRQLQKIDKSEGRFHVQNLSQVEQDGRTGHGLRRSSKFCLKEHKALKTLGIIMGTFTLCWLPFFIVNIVHVIQDNLIRKEVYILLNWIGYVNSGFNPLIYCRSPDFRIAFQELLCLRRSSLKAYGNGYSSNGNTGEQSGYHVEQEKENKLLCEDLPGTEDFVGHQGTVPSDNIDSQGRNCSTNDSLL,adrb2,90
+MAESSDKLYRVEYAKSGRASCKKCSESIPKDSLRMAIMVQSPMFDGKVPHWYHFSCFWKVGHSIRHPDVEVDGFSELRWDDQQKVKKTAEAGGVTGKGQDGIGSKAEKTLGDFAAEYAKSNRSTCKGCMEKIEKGQVRLSKKMVDPEKPQLGMIDRWYHPGCFVKNREELGFRPEYSASQLKGFSLLATEDKEALKKQLPGVKSEGKRKGDEVDGVDEVAKKKSKKEKDKDSKLEKALKAQNDLIWNIKDELKKVCSTNDLKELLIFNKQQVPSGESAILDRVADGMVFGALLPCEECSGQLVFKSDAYYCTGDVTAWTKCMVKTQTPNRKEWVTPKEFREISYLKKLKVKKQDRIFPPETSASVAATPPPSTASAPAAVNSSASADKPLSNMKILTLGKLSRNKDEVKAMIEKLGGKLTGTANKASLCISTKKEVEKMNKKMEEVKEANIRVVSEDFLQDVSASTKSLQELFLAHILSPWGAEVKAEPVEVVAPRGKSGAALSKKSKGQVKEEGINKSEKRMKLTLKGGAAVDPDSGLEHSAHVLEKGGKVFSATLGLVDIVKGTNSYYKLQLLEDDKENRYWIFRSWGRVGTVIGSNKLEQMPSKEDAIEHFMKLYEEKTGNAWHSKNFTKYPKKFYPLEIDYGQDEEAVKKLTVNPGTKSKLPKPVQDLIKMIFDVESMKKAMVEYEIDLQKMPLGKLSKRQIQAAYSILSEVQQAVSQGSSDSQILDLSNRFYTLIPHDFGMKKPPLLNNADSVQAKVEMLDNLLDIEVAYSLLRGGSDDSSKDPIDVNYEKLKTDIKVVDRDSEEAEIIRKYVKNTHATTHNAYDLEVIDIFKIEREGECQRYKPFKQLHNRRLLWHGSRTTNFAGILSQGLRIAPPEAPVTGYMFGKGIYFADMVSKSANYCHTSQGDPIGLILLGEVALGNMYELKHASHISKLPKGKHSVKGLGKTTPDPSANISLDGVDVPLGTGISSGVNDTSLLYNEYIVYDIAQVNLKYLLKLKFNFKTSLW,parp1,91
+MSRPLSDQEKRKQISVRGLAGVENVTELKKNFNRHLHFTLVKDRNVATPRDYYFALAHTVRDHLVGRWIRTQQHYYEKDPKRIYYLSLEFYMGRTLQNTMVNLALENACDEATYQLGLDMEELEEIEEDAGLGNGGLGRLAACFLDSMATLGLAAYGYGIRYEFGIFNQKISGGWQMEEADDWLRYGNPWEKARPEFTLPVHFYGHVEHTSQGAKWVDTQVVLAMPYDTPVPGYRNNVVNTMRLWSAKAPNDFNLKDFNVGGYIQAVLDRNLAENISRVLYPNDNFFEGKELRLKQEYFVVAATLQDIIRRFKSSKFGCRDPVRTNFDAFPDKVAIQLNDTHPSLAIPELMRILVDLERMDWDKAWDVTVRTCAYTNHTVLPEALERWPVHLLETLLPRHLQIIYEINQRFLNRVAAAFPGDVDRLRRMSLVEEGAVKRINMAHLCIAGSHAVNGVARIHSEILKKTIFKDFYELEPHKFQNKTNGITPRRWLVLCNPGLAEVIAERIGEDFISDLDQLRKLLSFVDDEAFIRDVAKVKQENKLKFAAYLEREYKVHINPNSLFDIQVKRIHEYKRQLLNCLHVITLYNRIKREPNKFFVPRTVMIGGKAAPGYHMAKMIIRLVTAIGDVVNHDPAVGDRLRVIFLENYRVSLAEKVIPAADLSEQISTAGTEASGTGNMKFMLNGALTIGTMDGANVEMAEEAGEENFFIFGMRVEDVDKLDQRGYNAQEYYDRIPELRQVIEQLSSGFFSPKQPDLFKDIVNMLMHHDRFKVFADYEDYIKCQEKVSALYKNPREWTRMVIRNIATSGKFSSDRTIAQYAREIWGVEPSRQRLPAPDEAI,pygm,92
+MTMTLHTKASGMALLHQIQGNELEPLNRPQLKIPLERPLGEVYLDSSKPAVYNYPEGAAYEFNAAAAANAQVYGQTGLPYGPGSEAAAFGSNGLGGFPPLNSVSPSPLMLLHPPPQLSPFLQPHGQQVPYYLENEPSGYTVREAGPPAFYRPNSDNRRQGGRERLASTNDKGSMAMESAKETRYCAVCNDYASGYHYGVWSCEGCKAFFKRSIQGHNDYMCPATNQCTIDKNRRKSCQACRLRKCYEVGMMKGGIRKDRRGGRMLKHKRQRDDGEGRGEVGSAGDMRAANLWPSPLMIKRSKKNSLALSLTADQMVSALLDAEPPILYSEYDPTRPFSEASMMGLLTNLADRELVHMINWAKRVPGFVDLTLHDQVHLLECAWLEILMIGLVWRSMEHPGKLLFAPNLLLDRNQGKCVEGMVEIFDMLLATSSRFRMMNLQGEEFVCLKSIILLNSGVYTFLSSTLKSLEEKDHIHRVLDKITDTLIHLMAKAGLTLQQQHQRLAQLLLILSHIRHMSNKGMEHLYSMKCKNVVPLYDLLLEMLDAHRLHAPTSRGGASVEETDQSHLATAGSTSSHSLQKYYITGEAEGFPATV,esr1,93
+MPEETQTQDQPMEEEEVETFAFQAEIAQLMSLIINTFYSNKEIFLRELISNSSDALDKIRYESLTDPSKLDSGKELHINLIPNKQDRTLTIVDTGIGMTKADLINNLGTIAKSGTKAFMEALQAGADISMIGQFGVGFYSAYLVAEKVTVITKHNDDEQYAWESSAGGSFTVRTDTGEPMGRGTKVILHLKEDQTEYLEERRIKEIVKKHSQFIGYPITLFVEKERDKEVSDDEAEEKEDKEEEKEKEEKESEDKPEIEDVGSDEEEEKKDGDKKKKKKIKEKYIDQEELNKTKPIWTRNPDDITNEEYGEFYKSLTNDWEDHLAVKHFSVEGQLEFRALLFVPRRAPFDLFENRKKKNNIKLYVRRVFIMDNCEELIPEYLNFIRGVVDSEDLPLNISREMLQQSKILKVIRKNLVKKCLELFTELAEDKENYKKFYEQFSKNIKLGIHEDSQNRKKLSELLRYYTSASGDEMVSLKDYCTRMKENQKHIYYITGETKDQVANSAFVERLRKHGLEVIYMIEPIDEYCVQQLKEFEGKTLVSVTKEGLELPEDEEEKKKQEEKKTKFENLCKIMKDILEKKVEKVVVSNRLVTSPCCIVTSTYGWTANMERIMKAQALRDNSTMGYMAAKKHLEINPDHSIIETLRQKAEADKNDKSVKDLVILLYETALLSSGFSLEDPQTHANRIYRMIKLGLGIDEDDPTADDTSAAVTEEMPPLEGDDDTSRMEEVD,hs90a,94
+MGAASGRRGPGLLLPLPLLLLLPPQPALALDPGLQPGNFSADEAGAQLFAQSYNSSAEQVLFQSVAASWAHDTNITAENARRQEEAALLSQEFAEAWGQKAKELYEPIWQNFTDPQLRRIIGAVRTLGSANLPLAKRQQYNALLSNMSRIYSTAKVCLPNKTATCWSLDPDLTNILASSRSYAMLLFAWEGWHNAAGIPLKPLYEDFTALSNEAYKQDGFTDTGAYWRSWYNSPTFEDDLEHLYQQLEPLYLNLHAFVRRALHRRYGDRYINLRGPIPAHLLGDMWAQSWENIYDMVVPFPDKPNLDVTSTMLQQGWNATHMFRVAEEFFTSLELSPMPPEFWEGSMLEKPADGREVVCHASAWDFYNRKDFRIKQCTRVTMDQLSTVHHEMGHIQYYLQYKDLPVSLRRGANPGFHEAIGDVLALSVSTPEHLHKIGLLDRVTNDTESDINYLLKMALEKIAFLPFGYLVDQWRWGVFSGRTPPSRYNFDWWYLRTKYQGICPPVTRNETHFDAGAKFHVPNVTPYIRYFVSFVLQFQFHEALCKEAGYEGPLHQCDIYRSTKAGAKLRKVLQAGSSRPWQEVLKDMVGLDALDAQPLLKYFQPVTQWLQEQNQQNGEVLGWPEYQWHPPLPDNYPEGIDLVTDEAEASKFVEEYDRTSQVVWNEYAEANWNYNTNITTETSKILLQKNMQIANHTLKYGTQARKFDVNQLQNTTIKRIIKKVQDLERAALPAQELEEYNKILLDMETTYSVATVCHPNGSCLQLEPDLTNVMATSRKYEDLLWAWEGWRDKAGRAILQFYPKYVELINQAARLNGYVDAGDSWRSMYETPSLEQDLERLFQELQPLYLNLHAYVRRALHRHYGAQHINLEGPIPAHLLGNMWAQTWSNIYDLVVPFPSAPSMDTTEAMLKQGWTPRRMFKEADDFFTSLGLLPVPPEFWNKSMLEKPTDGREVVCHASAWDFYNGKDFRIKQCTTVNLEDLVVAHHEMGHIQYFMQYKDLPVALREGANPGFHEAIGDVLALSVSTPKHLHSLNLLSSEGGSDEHDINFLMKMALDKIAFIPFSYLVDQWRWRVFDGSITKENYNQEWWSLRLKYQGLCPPVPRTQGDFDPGAKFHIPSSVPYIRYFVSFIIQFQFHEALCQAAGHTGPLHKCDIYQSKEAGQRLATAMKLGFSRPWPEAMQLITGQPNMSASAMLSYFKPLLDWLRTENELHGEKLGWPQYNWTPNSARSEGPLPDSGRVSFLGLDLDAQQARVGQWLLLFLGIALLVATLGLSQRLFSIRHRSLHRHSHGPQFGSEVELRHS,ace,95
+MRPPQCLLHTPSLASPLLLLLLWLLGGGVGAEGREDAELLVTVRGGRLRGIRLKTPGGPVSAFLGIPFAEPPMGPRRFLPPEPKQPWSGVVDATTFQSVCYQYVDTLYPGFEGTEMWNPNRELSEDCLYLNVWTPYPRPTSPTPVLVWIYGGGFYSGASSLDVYDGRFLVQAERTVLVSMNYRVGAFGFLALPGSREAPGNVGLLDQRLALQWVQENVAAFGGDPTSVTLFGESAGAASVGMHLLSPPSRGLFHRAVLQSGAPNGPWATVGMGEARRRATQLAHLVGCPPGGTGGNDTELVACLRTRPAQVLVNHEWHVLPQESVFRFSFVPVVDGDFLSDTPEALINAGDFHGLQVLVGVVKDEGSYFLVYGAPGFSKDNESLISRAEFLAGVRVGVPQVSDLAAEAVVLHYTDWLHPEDPARLREALSDVVGDHNVVCPVAQLAGRLAAQGARVYAYVFEHRASTLSWPLWMGVPHGYEIEFIFGIPLDPSRNYTAEEKIFAQRLMRYWANFARTGDPNEPRDPKAPQWPPYTAGAQQYVSLDLRPLEVRRGLRAQACAFWNRFLPKLLSATDTLDEAERQWKAEFHRWSSYMVHWKNQFDHYSKQDRCSDL,aces,96
+MEQPQEEAPEVREEEEKEEVAEAEGAPELNGGPQHALPSSSYTDLSRSSSPPSLLDQLQMGCDGASCGSLNMECRVCGDKASGFHYGVHACEGCKGFFRRTIRMKLEYEKCERSCKIQKKNRNKCQYCRFQKCLALGMSHNAIRFGRMPEAEKRKLVAGLTANEGSQYNPQVADLKAFSKHIYNAYLKNFNMTKKKARSILTGKASHTAPFVIHDIETLWQAEKGLVWKQLVNGLPPYKEISVHVFYRCQCTTVETVRELTEFAKSIPSFSSLFLNDQVTLLKYGVHEAIFAMLASIVNKDGLLVANGSGFVTREFLRSLRKPFSDIIEPKFEFAVKFNALELDDSDLALFIAAIILCGDRPGLMNVPRVEAIQDTILRALEFHLQANHPDAQYLFPKLLQKMADLRQLVTEHAQMMQRIKKTETETSLHPLLQEIYKDMY,ppard,97
+MENGYTYEDYKNTAEWLLSHTKHRPQVAIICGSGLGGLTDKLTQAQIFDYGEIPNFPRSTVPGHAGRLVFGFLNGRACVMMQGRFHMYEGYPLWKVTFPVRVFHLLGVDTLVVTNAAGGLNPKFEVGDIMLIRDHINLPGFSGQNPLRGPNDERFGDRFPAMSDAYDRTMRQRALSTWKQMGEQRELQEGTYVMVAGPSFETVAECRVLQKLGADAVGMSTVPEVIVARHCGLRVFGFSLITNKVIMDYESLEKANHEEVLAAGKQAAQKLEQFVSILMASIPLPDKAS,pnph,98
+MLEICLKLVGCKSKKGLSSSSSCYLEEALQRPVASDFEPQGLSEAARWNSKENLLAGPSENDPNLFVALYDFVASGDNTLSITKGEKLRVLGYNHNGEWCEAQTKNGQGWVPSNYITPVNSLEKHSWYHGPVSRNAAEYLLSSGINGSFLVRESESSPGQRSISLRYEGRVYHYRINTASDGKLYVSSESRFNTLAELVHHHSTVADGLITTLHYPAPKRNKPTVYGVSPNYDKWEMERTDITMKHKLGGGQYGEVYEGVWKKYSLTVAVKTLKEDTMEVEEFLKEAAVMKEIKHPNLVQLLGVCTREPPFYIITEFMTYGNLLDYLRECNRQEVNAVVLLYMATQISSAMEYLEKKNFIHRDLAARNCLVGENHLVKVADFGLSRLMTGDTYTAHAGAKFPIKWTAPESLAYNKFSIKSDVWAFGVLLWEIATYGMSPYPGIDLSQVYELLEKDYRMERPEGCPEKVYELMRACWQWNPSDRPSFAEIHQAFETMFQESSISDEVEKELGKQGVRGAVSTLLQAPELPTKTRTSRRAAEHRDTTDVPEMPHSKGQGESDPLDHEPAVSPLLPRKERGPPEGGLNEDERLLPKDKKTNLFSALIKKKKKTAPTPPKRSSSFREMDGQPERRGAGEEEGRDISNGALAFTPLDTADPAKSPKPSNGAGVPNGALRESGGSGFRSPHLWKKSSTLTSSRLATGEEEGGGSSSKRFLRSCSASCVPHGAKDTEWRSVTLPRDLQSTGRQFDSSTFGGHKSEKPALPRKRAGENRSDQVTRGTVTPPPRLVKKNEEAADEVFKDIMESSPGSSPPNLTPKPLRRQVTVAPASGLPHKEEAGKGSALGTPAAAEPVTPTSKAGSGAPGGTSKGPAEESRVRRHKHSSESPGRDKGKLSRLKPAPPPPPAASAGKAGGKPSQSPSQEAAGEAVLGAKTKATSLVDAVNSDAAKPSQPGEGLKKPVLPATPKPQSAKPSGTPISPAPVPSTLPSASSALAGDQPSSTAFIPLISTRVSLRKTRQPPERIASGAITKGVVLDSTEALCLAISRNSEQMASHSAVLEAGKNLYTFCVSYVDSIQQMRNKFAFREAINKLENNLRELQICPATAGSGPAATQDFSKLLSSVKEISDIVQR,abl1,99
+MDSLVVLVLCLSCLLLLSLWRQSSGRGKLPPGPTPLPVIGNILQIGIKDISKSLTNLSKVYGPVFTLYFGLKPIVVLHGYEAVKEALIDLGEEFSGRGIFPLAERANRGFGIVFSNGKKWKEIRRFSLMTLRNFGMGKRSIEDRVQEEARCLVEELRKTKASPCDPTFILGCAPCNVICSIIFHKRFDYKDQQFLNLMEKLNENIKILSSPWIQICNNFSPIIDYFPGTHNKLLKNVAFMKSYILEKVKEHQESMDMNNPQDFIDCFLMKMEKEKHNQPSEFTIESLENTAVDLFGAGTETTSTTLRYALLLLLKHPEVTAKVQEEIERVIGRNRSPCMQDRSHMPYTDAVVHEVQRYIDLLPTSLPHAVTCDIKFRNYLIPKGTTILISLTSVLHDNKEFPNPEMFDPHHFLDEGGNFKKSKYFMPFSAGKRICVGEALAGMELFLFLTSILQNFNLKSLVDPKNLDTTPVVNGFASVPPFYQLCFIPV,cp2c9,100
+METKGYHSLPEGLDMERRWGQVSQAVERSSLGPTERTDENNYMEIVNVSCVSGAIPNNSTQGSSKEKQELLPCLQQDNNRPGILTSDIKTELESKELSATVAESMGLYMDSVRDADYSYEQQNQQGSMSPAKIYQNVEQLVKFYKGNGHRPSTLSCVNTPLRSFMSDSGSSVNGGVMRAVVKSPIMCHEKSPSVCSPLNMTSSVCSPAGINSVSSTTASFGSFPVHSPITQGTPLTCSPNVENRGSRSHSPAHASNVGSPLSSPLSSMKSSISSPPSHCSVKSPVSSPNNVTLRSSVSSPANINNSRCSVSSPSNTNNRSTLSSPAASTVGSICSPVNNAFSYTASGTSAGSSTLRDVVPSPDTQEKGAQEVPFPKTEEVESAISNGVTGQLNIVQYIKPEPDGAFSSSCLGGNSKINSDSSFSVPIKQESTKHSCSGTSFKGNPTVNPFPFMDGSYFSFMDDKDYYSLSGILGPPVPGFDGNCEGSGFPVGIKQEPDDGSYYPEASIPSSAIVGVNSGGQSFHYRIGAQGTISLSRSARDQSFQHLSSFPPVNTLVESWKSHGDLSSRRSDGYPVLEYIPENVSSSTLRSVSTGSSRPSKICLVCGDEASGCHYGVVTCGSCKVFFKRAVEGQHNYLCAGRNDCIIDKIRRKNCPACRLQKCLQAGMNLGARKSKKLGKLKGIHEEQPQQQQPPPPPPPPQSPEEGTTYIAPAKEPSVNTALVPQLSTISRALTPSPVMVLENIEPEIVYAGYDSSKPDTAENLLSTLNRLAGKQMIQVVKWAKVLPGFKNLPLEDQITLIQYSWMCLSSFALSWRSYKHTNSQFLYFAPDLVFNEEKMHQSAMYELCQGMHQISLQFVRLQLTFEEYTIMKVLLLLSTIPKDGLKSQAAFEEMRTNYIKELRKMVTKCPNNSGQSWQRFYQLTKLLDSMHDLVSDLLEFCFYTFRESHALKVEFPAMLVEIISDQLPKVESGNAKPLYFHRK,mcr,101

data/datasets/AD/saliency.csv

@@ -0,0 +1 @@
+CCCCCCC(C(C)O)n1cncn1,ada,1

data/features.py

@@ -0,0 +1,136 @@
+# allowable multiple choice node and edge features 
+allowable_features = {
+    'possible_atomic_num_list' : list(range(1, 119)) + ['misc'],
+    'possible_chirality_list' : [
+        'CHI_UNSPECIFIED',
+        'CHI_TETRAHEDRAL_CW',
+        'CHI_TETRAHEDRAL_CCW',
+        'CHI_OTHER'
+    ],
+    'possible_degree_list' : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'misc'],
+    'possible_formal_charge_list' : [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 'misc'],
+    'possible_numH_list' : [0, 1, 2, 3, 4, 5, 6, 7, 8, 'misc'],
+    'possible_number_radical_e_list': [0, 1, 2, 3, 4, 'misc'],
+    'possible_hybridization_list' : [
+        'SP', 'SP2', 'SP3', 'SP3D', 'SP3D2', 'misc'
+        ],
+    'possible_is_aromatic_list': [False, True],
+    'possible_is_in_ring_list': [False, True],
+    'possible_bond_type_list' : [
+        'SINGLE',
+        'DOUBLE',
+        'TRIPLE',
+        'AROMATIC',
+        'misc'
+    ],
+    'possible_bond_stereo_list': [
+        'STEREONONE',
+        'STEREOZ',
+        'STEREOE',
+        'STEREOCIS',
+        'STEREOTRANS',
+        'STEREOANY',
+    ], 
+    'possible_is_conjugated_list': [False, True],
+    'posible_explicit_valence': [1, 2, 3, 4, 5, 6, 7, 'misc'],
+    'posible_implicit_valence': [1, 2, 3, 4, 5, 6, 7, 'misc']
+}
+
+def safe_index(l, e):
+    """
+    Return index of element e in list l. If e is not present, return the last index
+    """
+    try:
+        return l.index(e)
+    except:
+        return len(l) - 1
+
+def atom_to_feature_vector(atom):
+    """
+    Converts rdkit atom object to feature list of indices
+    :param mol: rdkit atom object
+    :return: list
+    """
+    atom_feature = [
+            safe_index(allowable_features['possible_atomic_num_list'], atom.GetAtomicNum()),
+            allowable_features['possible_chirality_list'].index(str(atom.GetChiralTag())),
+            safe_index(allowable_features['possible_degree_list'], atom.GetTotalDegree()),
+            safe_index(allowable_features['possible_formal_charge_list'], atom.GetFormalCharge()),
+            safe_index(allowable_features['possible_numH_list'], atom.GetTotalNumHs()),
+            safe_index(allowable_features['possible_number_radical_e_list'], atom.GetNumRadicalElectrons()),
+            safe_index(allowable_features['possible_hybridization_list'], str(atom.GetHybridization())),
+            allowable_features['possible_is_aromatic_list'].index(atom.GetIsAromatic()),
+            allowable_features['possible_is_in_ring_list'].index(atom.IsInRing()),
+            ]
+    return atom_feature
+
+def get_atom_feature_dims():
+    return list(map(len, [
+        allowable_features['possible_atomic_num_list'],
+        allowable_features['possible_chirality_list'],
+        allowable_features['possible_degree_list'],
+        allowable_features['possible_formal_charge_list'],
+        allowable_features['possible_numH_list'],
+        allowable_features['possible_number_radical_e_list'],
+        allowable_features['possible_hybridization_list'],
+        allowable_features['possible_is_aromatic_list'],
+        allowable_features['possible_is_in_ring_list'],
+        ]))
+
+def bond_to_feature_vector(bond):
+    """
+    Converts rdkit bond object to feature list of indices
+    :param mol: rdkit bond object
+    :return: list
+    """
+    bond_feature = [
+                safe_index(allowable_features['possible_bond_type_list'], str(bond.GetBondType())),
+                allowable_features['possible_bond_stereo_list'].index(str(bond.GetStereo())),
+                allowable_features['possible_is_conjugated_list'].index(bond.GetIsConjugated()),
+            ]
+    return bond_feature
+
+def get_bond_feature_dims():
+    return list(map(len, [
+        allowable_features['possible_bond_type_list'],
+        allowable_features['possible_bond_stereo_list'],
+        allowable_features['possible_is_conjugated_list']
+        ]))
+
+def atom_feature_vector_to_dict(atom_feature):
+    [atomic_num_idx, 
+    chirality_idx,
+    degree_idx,
+    formal_charge_idx,
+    num_h_idx,
+    number_radical_e_idx,
+    hybridization_idx,
+    is_aromatic_idx,
+    is_in_ring_idx] = atom_feature
+
+    feature_dict = {
+        'atomic_num': allowable_features['possible_atomic_num_list'][atomic_num_idx],
+        'chirality': allowable_features['possible_chirality_list'][chirality_idx],
+        'degree': allowable_features['possible_degree_list'][degree_idx],
+        'formal_charge': allowable_features['possible_formal_charge_list'][formal_charge_idx],
+        'num_h': allowable_features['possible_numH_list'][num_h_idx],
+        'num_rad_e': allowable_features['possible_number_radical_e_list'][number_radical_e_idx],
+        'hybridization': allowable_features['possible_hybridization_list'][hybridization_idx],
+        'is_aromatic': allowable_features['possible_is_aromatic_list'][is_aromatic_idx],
+        'is_in_ring': allowable_features['possible_is_in_ring_list'][is_in_ring_idx]
+    }
+
+    return feature_dict
+
+def bond_feature_vector_to_dict(bond_feature):
+    [bond_type_idx, 
+    bond_stereo_idx,
+    is_conjugated_idx] = bond_feature
+
+    feature_dict = {
+        'bond_type': allowable_features['possible_bond_type_list'][bond_type_idx],
+        'bond_stereo': allowable_features['possible_bond_stereo_list'][bond_stereo_idx],
+        'is_conjugated': allowable_features['possible_is_conjugated_list'][is_conjugated_idx]
+    }
+
+    return feature_dict

example/input_smiles.csv

@@ -0,0 +1,4 @@
+smiles
+Cn4c(CCC(=O)Nc3ccc2ccn(CC[C@H](CO)n1cnc(C(N)=O)c1)c2c3)nc5ccccc45
+OCCCCCn1cnc2C(O)CN=CNc12
+Nc4nc(c1ccco1)c3ncn(C(=O)NCCc2ccccc2)c3n4

gcn_lib/dense/__init__.py

@@ -0,0 +1,4 @@
+from .torch_nn import *
+from .torch_edge import *
+from .torch_vertex import *
+

gcn_lib/dense/torch_edge.py

@@ -0,0 +1,101 @@
+import torch
+from torch import nn
+from torch_cluster import knn_graph
+
+
+class DenseDilated(nn.Module):
+    """
+    Find dilated neighbor from neighbor list
+
+    edge_index: (2, batch_size, num_points, k)
+    """
+    def __init__(self, k=9, dilation=1, stochastic=False, epsilon=0.0):
+        super(DenseDilated, self).__init__()
+        self.dilation = dilation
+        self.stochastic = stochastic
+        self.epsilon = epsilon
+        self.k = k
+
+    def forward(self, edge_index):
+        if self.stochastic:
+            if torch.rand(1) < self.epsilon and self.training:
+                num = self.k * self.dilation
+                randnum = torch.randperm(num)[:self.k]
+                edge_index = edge_index[:, :, :, randnum]
+            else:
+                edge_index = edge_index[:, :, :, ::self.dilation]
+        else:
+            edge_index = edge_index[:, :, :, ::self.dilation]
+        return edge_index
+
+
+def pairwise_distance(x):
+    """
+    Compute pairwise distance of a point cloud.
+    Args:
+        x: tensor (batch_size, num_points, num_dims)
+    Returns:
+        pairwise distance: (batch_size, num_points, num_points)
+    """
+    x_inner = -2*torch.matmul(x, x.transpose(2, 1))
+    x_square = torch.sum(torch.mul(x, x), dim=-1, keepdim=True)
+    return x_square + x_inner + x_square.transpose(2, 1)
+
+
+def dense_knn_matrix(x, k=16):
+    """Get KNN based on the pairwise distance.
+    Args:
+        x: (batch_size, num_dims, num_points, 1)
+        k: int
+    Returns:
+        nearest neighbors: (batch_size, num_points ,k) (batch_size, num_points, k)
+    """
+    with torch.no_grad():
+        x = x.transpose(2, 1).squeeze(-1)
+        batch_size, n_points, n_dims = x.shape
+        _, nn_idx = torch.topk(-pairwise_distance(x.detach()), k=k)
+        center_idx = torch.arange(0, n_points, device=x.device).repeat(batch_size, k, 1).transpose(2, 1)
+    return torch.stack((nn_idx, center_idx), dim=0)
+
+
+class DenseDilatedKnnGraph(nn.Module):
+    """
+    Find the neighbors' indices based on dilated knn
+    """
+    def __init__(self, k=9, dilation=1, stochastic=False, epsilon=0.0):
+        super(DenseDilatedKnnGraph, self).__init__()
+        self.dilation = dilation
+        self.stochastic = stochastic
+        self.epsilon = epsilon
+        self.k = k
+        self._dilated = DenseDilated(k, dilation, stochastic, epsilon)
+        self.knn = dense_knn_matrix
+
+    def forward(self, x):
+        edge_index = self.knn(x, self.k * self.dilation)
+        return self._dilated(edge_index)
+
+
+class DilatedKnnGraph(nn.Module):
+    """
+    Find the neighbors' indices based on dilated knn
+    """
+    def __init__(self, k=9, dilation=1, stochastic=False, epsilon=0.0):
+        super(DilatedKnnGraph, self).__init__()
+        self.dilation = dilation
+        self.stochastic = stochastic
+        self.epsilon = epsilon
+        self.k = k
+        self._dilated = DenseDilated(k, dilation, stochastic, epsilon)
+        self.knn = knn_graph
+
+    def forward(self, x):
+        x = x.squeeze(-1)
+        B, C, N = x.shape
+        edge_index = []
+        for i in range(B):
+            edgeindex = self.knn(x[i].contiguous().transpose(1, 0).contiguous(), self.k * self.dilation)
+            edgeindex = edgeindex.view(2, N, self.k * self.dilation)
+            edge_index.append(edgeindex)
+        edge_index = torch.stack(edge_index, dim=1)
+        return self._dilated(edge_index)

gcn_lib/dense/torch_nn.py

@@ -0,0 +1,93 @@
+import torch
+from torch import nn
+from torch.nn import Sequential as Seq, Linear as Lin, Conv2d
+
+
+##############################
+#    Basic layers
+##############################
+def act_layer(act, inplace=False, neg_slope=0.2, n_prelu=1):
+    # activation layer
+
+    act = act.lower()
+    if act == 'relu':
+        layer = nn.ReLU(inplace)
+    elif act == 'leakyrelu':
+        layer = nn.LeakyReLU(neg_slope, inplace)
+    elif act == 'prelu':
+        layer = nn.PReLU(num_parameters=n_prelu, init=neg_slope)
+    else:
+        raise NotImplementedError('activation layer [%s] is not found' % act)
+    return layer
+
+
+def norm_layer(norm, nc):
+    # normalization layer 2d
+    norm = norm.lower()
+    if norm == 'batch':
+        layer = nn.BatchNorm2d(nc, affine=True)
+    elif norm == 'instance':
+        layer = nn.InstanceNorm2d(nc, affine=False)
+    else:
+        raise NotImplementedError('normalization layer [%s] is not found' % norm)
+    return layer
+
+
+class MLP(Seq):
+    def __init__(self, channels, act='relu', norm=None, bias=True):
+        m = []
+        for i in range(1, len(channels)):
+            m.append(Lin(channels[i - 1], channels[i], bias))
+            if act is not None and act.lower() != 'none':
+                m.append(act_layer(act))
+            if norm is not None and norm.lower() != 'none':
+                m.append(norm_layer(norm, channels[-1]))
+        super(MLP, self).__init__(*m)
+
+
+class BasicConv(Seq):
+    def __init__(self, channels, act='relu', norm=None, bias=True, drop=0.):
+        m = []
+        for i in range(1, len(channels)):
+            m.append(Conv2d(channels[i - 1], channels[i], 1, bias=bias))
+            if act is not None and act.lower() != 'none':
+                m.append(act_layer(act))
+            if norm is not None and norm.lower() != 'none':
+                m.append(norm_layer(norm, channels[-1]))
+            if drop > 0:
+                m.append(nn.Dropout2d(drop))
+
+        super(BasicConv, self).__init__(*m)
+
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight)
+                if m.bias is not None:
+                    nn.init.zeros_(m.bias)
+            elif isinstance(m, nn.BatchNorm2d) or isinstance(m, nn.InstanceNorm2d):
+                m.weight.data.fill_(1)
+                m.bias.data.zero_()
+
+
+def batched_index_select(inputs, index):
+    """
+
+    :param inputs: torch.Size([batch_size, num_dims, num_vertices, 1])
+    :param index: torch.Size([batch_size, num_vertices, k])
+    :return: torch.Size([batch_size, num_dims, num_vertices, k])
+    """
+
+    batch_size, num_dims, num_vertices, _ = inputs.shape
+    k = index.shape[2]
+    idx = torch.arange(0, batch_size) * num_vertices
+    idx = idx.view(batch_size, -1)
+
+    inputs = inputs.transpose(2, 1).contiguous().view(-1, num_dims)
+    index = index.view(batch_size, -1) + idx.type(index.dtype).to(inputs.device)
+    index = index.view(-1)
+
+    return torch.index_select(inputs, 0, index).view(batch_size, -1, num_dims).transpose(2, 1).view(batch_size, num_dims, -1, k)
+

gcn_lib/dense/torch_vertex.py

@@ -0,0 +1,115 @@
+import torch
+from torch import nn
+from .torch_nn import BasicConv, batched_index_select
+from .torch_edge import DenseDilatedKnnGraph, DilatedKnnGraph
+import torch.nn.functional as F
+
+
+class MRConv2d(nn.Module):
+    """
+    Max-Relative Graph Convolution (Paper: https://arxiv.org/abs/1904.03751) for dense data type
+    """
+    def __init__(self, in_channels, out_channels, act='relu', norm=None, bias=True):
+        super(MRConv2d, self).__init__()
+        self.nn = BasicConv([in_channels*2, out_channels], act, norm, bias)
+
+    def forward(self, x, edge_index):
+        x_i = batched_index_select(x, edge_index[1])
+        x_j = batched_index_select(x, edge_index[0])
+        x_j, _ = torch.max(x_j - x_i, -1, keepdim=True)
+        return self.nn(torch.cat([x, x_j], dim=1))
+
+
+class EdgeConv2d(nn.Module):
+    """
+    Edge convolution layer (with activation, batch normalization) for dense data type
+    """
+    def __init__(self, in_channels, out_channels, act='relu', norm=None, bias=True):
+        super(EdgeConv2d, self).__init__()
+        self.nn = BasicConv([in_channels * 2, out_channels], act, norm, bias)
+
+    def forward(self, x, edge_index):
+        x_i = batched_index_select(x, edge_index[1])
+        x_j = batched_index_select(x, edge_index[0])
+        max_value, _ = torch.max(self.nn(torch.cat([x_i, x_j - x_i], dim=1)), -1, keepdim=True)
+        return max_value
+
+
+class GraphConv2d(nn.Module):
+    """
+    Static graph convolution layer
+    """
+    def __init__(self, in_channels, out_channels, conv='edge', act='relu', norm=None, bias=True):
+        super(GraphConv2d, self).__init__()
+        if conv == 'edge':
+            self.gconv = EdgeConv2d(in_channels, out_channels, act, norm, bias)
+        elif conv == 'mr':
+            self.gconv = MRConv2d(in_channels, out_channels, act, norm, bias)
+        else:
+            raise NotImplementedError('conv:{} is not supported'.format(conv))
+
+    def forward(self, x, edge_index):
+        return self.gconv(x, edge_index)
+
+
+class DynConv2d(GraphConv2d):
+    """
+    Dynamic graph convolution layer
+    """
+    def __init__(self, in_channels, out_channels, kernel_size=9, dilation=1, conv='edge', act='relu',
+                 norm=None, bias=True, stochastic=False, epsilon=0.0, knn='matrix'):
+        super(DynConv2d, self).__init__(in_channels, out_channels, conv, act, norm, bias)
+        self.k = kernel_size
+        self.d = dilation
+        if knn == 'matrix':
+            self.dilated_knn_graph = DenseDilatedKnnGraph(kernel_size, dilation, stochastic, epsilon)
+        else:
+            self.dilated_knn_graph = DilatedKnnGraph(kernel_size, dilation, stochastic, epsilon)
+
+    def forward(self, x):
+        edge_index = self.dilated_knn_graph(x)
+        return super(DynConv2d, self).forward(x, edge_index)
+
+    
+class PlainDynBlock2d(nn.Module):
+    """
+    Plain Dynamic graph convolution block
+    """
+    def __init__(self, in_channels, kernel_size=9, dilation=1, conv='edge', act='relu', norm=None,
+                 bias=True,  stochastic=False, epsilon=0.0, knn='matrix'):
+        super(PlainDynBlock2d, self).__init__()
+        self.body = DynConv2d(in_channels, in_channels, kernel_size, dilation, conv,
+                              act, norm, bias, stochastic, epsilon, knn)
+
+    def forward(self, x):
+        return self.body(x)
+    
+    
+class ResDynBlock2d(nn.Module):
+    """
+    Residual Dynamic graph convolution block
+    """
+    def __init__(self, in_channels, kernel_size=9, dilation=1, conv='edge', act='relu', norm=None,
+                 bias=True,  stochastic=False, epsilon=0.0, knn='matrix', res_scale=1):
+        super(ResDynBlock2d, self).__init__()
+        self.body = DynConv2d(in_channels, in_channels, kernel_size, dilation, conv,
+                              act, norm, bias, stochastic, epsilon, knn)
+        self.res_scale = res_scale
+
+    def forward(self, x):
+        return self.body(x) + x*self.res_scale
+
+
+class DenseDynBlock2d(nn.Module):
+    """
+    Dense Dynamic graph convolution block
+    """
+    def __init__(self, in_channels, out_channels=64,  kernel_size=9, dilation=1, conv='edge',
+                 act='relu', norm=None,bias=True, stochastic=False, epsilon=0.0, knn='matrix'):
+        super(DenseDynBlock2d, self).__init__()
+        self.body = DynConv2d(in_channels, out_channels, kernel_size, dilation, conv,
+                              act, norm, bias, stochastic, epsilon, knn)
+
+    def forward(self, x):
+        dense = self.body(x)
+        return torch.cat((x, dense), 1)

gcn_lib/sparse/__init__.py

@@ -0,0 +1,4 @@
+from .torch_nn import *
+from .torch_edge import *
+from .torch_vertex import *
+

gcn_lib/sparse/torch_edge.py

@@ -0,0 +1,113 @@
+import torch
+from torch import nn
+from torch_cluster import knn_graph
+
+
+class Dilated(nn.Module):
+    """
+    Find dilated neighbor from neighbor list
+    """
+    def __init__(self, k=9, dilation=1, stochastic=False, epsilon=0.0):
+        super(Dilated, self).__init__()
+        self.dilation = dilation
+        self.stochastic = stochastic
+        self.epsilon = epsilon
+        self.k = k
+
+    def forward(self, edge_index, batch=None):
+        if self.stochastic:
+            if torch.rand(1) < self.epsilon and self.training:
+                num = self.k * self.dilation
+                randnum = torch.randperm(num)[:self.k]
+                edge_index = edge_index.view(2, -1, num)
+                edge_index = edge_index[:, :, randnum]
+                return edge_index.view(2, -1)
+            else:
+                edge_index = edge_index[:, ::self.dilation]
+        else:
+            edge_index = edge_index[:, ::self.dilation]
+        return edge_index
+
+
+class DilatedKnnGraph(nn.Module):
+    """
+    Find the neighbors' indices based on dilated knn
+    """
+    def __init__(self, k=9, dilation=1, stochastic=False, epsilon=0.0, knn='matrix'):
+        super(DilatedKnnGraph, self).__init__()
+        self.dilation = dilation
+        self.stochastic = stochastic
+        self.epsilon = epsilon
+        self.k = k
+        self._dilated = Dilated(k, dilation, stochastic, epsilon)
+        if knn == 'matrix':
+            self.knn = knn_graph_matrix
+        else:
+            self.knn = knn_graph
+
+    def forward(self, x, batch):
+        edge_index = self.knn(x, self.k * self.dilation, batch)
+        return self._dilated(edge_index, batch)
+
+
+def pairwise_distance(x):
+    """
+    Compute pairwise distance of a point cloud.
+    Args:
+        x: tensor (batch_size, num_points, num_dims)
+    Returns:
+        pairwise distance: (batch_size, num_points, num_points)
+    """
+    x_inner = -2*torch.matmul(x, x.transpose(2, 1))
+    x_square = torch.sum(torch.mul(x, x), dim=-1, keepdim=True)
+    return x_square + x_inner + x_square.transpose(2, 1)
+
+
+def knn_matrix(x, k=16, batch=None):
+    """Get KNN based on the pairwise distance.
+    Args:
+        pairwise distance: (num_points, num_points)
+        k: int
+    Returns:
+        nearest neighbors: (num_points*k ,1) (num_points, k)
+    """
+    with torch.no_grad():
+        if batch is None:
+            batch_size = 1
+        else:
+            batch_size = batch[-1] + 1
+        x = x.view(batch_size, -1, x.shape[-1])
+
+        neg_adj = -pairwise_distance(x.detach())
+        _, nn_idx = torch.topk(neg_adj, k=k)
+        del neg_adj
+
+        n_points = x.shape[1]
+        start_idx = torch.arange(0, n_points*batch_size, n_points).long().view(batch_size, 1, 1)
+        if x.is_cuda:
+            start_idx = start_idx.cuda()
+        nn_idx += start_idx
+        del start_idx
+
+        if x.is_cuda:
+            torch.cuda.empty_cache()
+
+        nn_idx = nn_idx.view(1, -1)
+        center_idx = torch.arange(0, n_points*batch_size).repeat(k, 1).transpose(1, 0).contiguous().view(1, -1)
+        if x.is_cuda:
+            center_idx = center_idx.cuda()
+    return nn_idx, center_idx
+
+
+def knn_graph_matrix(x, k=16, batch=None):
+    """Construct edge feature for each point
+    Args:
+        x: (num_points, num_dims)
+        batch: (num_points, )
+        k: int
+    Returns:
+        edge_index: (2, num_points*k)
+    """
+    nn_idx, center_idx = knn_matrix(x, k, batch)
+    return torch.cat((nn_idx, center_idx), dim=0)
+

gcn_lib/sparse/torch_message.py

@@ -0,0 +1,98 @@
+import torch
+import torch.nn.functional as F
+from torch_geometric.nn import MessagePassing
+from torch_scatter import scatter, scatter_softmax
+from torch_geometric.utils import degree
+
+
+class GenMessagePassing(MessagePassing):
+    def __init__(self, aggr='softmax',
+                 t=1.0, learn_t=False,
+                 p=1.0, learn_p=False,
+                 y=0.0, learn_y=False):
+
+        if aggr in ['softmax_sg', 'softmax', 'softmax_sum']:
+
+            super(GenMessagePassing, self).__init__(aggr=None)
+            self.aggr = aggr
+
+            if learn_t and (aggr == 'softmax' or aggr == 'softmax_sum'):
+                self.learn_t = True
+                self.t = torch.nn.Parameter(torch.Tensor([t]), requires_grad=True)
+            else:
+                self.learn_t = False
+                self.t = t
+
+            if aggr == 'softmax_sum':
+                self.y = torch.nn.Parameter(torch.Tensor([y]), requires_grad=learn_y)
+
+        elif aggr in ['power', 'power_sum']:
+
+            super(GenMessagePassing, self).__init__(aggr=None)
+            self.aggr = aggr
+
+            if learn_p:
+                self.p = torch.nn.Parameter(torch.Tensor([p]), requires_grad=True)
+            else:
+                self.p = p
+
+            if aggr == 'power_sum':
+                self.y = torch.nn.Parameter(torch.Tensor([y]), requires_grad=learn_y)
+        else:
+            super(GenMessagePassing, self).__init__(aggr=aggr)
+
+    def aggregate(self, inputs, index, ptr=None, dim_size=None):
+
+        if self.aggr in ['add', 'mean', 'max', None]:
+            return super(GenMessagePassing, self).aggregate(inputs, index, ptr, dim_size)
+
+        elif self.aggr in ['softmax_sg', 'softmax', 'softmax_sum']:
+
+            if self.learn_t:
+                out = scatter_softmax(inputs*self.t, index, dim=self.node_dim)
+            else:
+                with torch.no_grad():
+                    out = scatter_softmax(inputs*self.t, index, dim=self.node_dim)
+
+            out = scatter(inputs*out, index, dim=self.node_dim,
+                          dim_size=dim_size, reduce='sum')
+
+            if self.aggr == 'softmax_sum':
+                self.sigmoid_y = torch.sigmoid(self.y)
+                degrees = degree(index, num_nodes=dim_size).unsqueeze(1)
+                out = torch.pow(degrees, self.sigmoid_y) * out
+
+            return out
+
+
+        elif self.aggr in ['power', 'power_sum']:
+            min_value, max_value = 1e-7, 1e1
+            torch.clamp_(inputs, min_value, max_value)
+            out = scatter(torch.pow(inputs, self.p), index, dim=self.node_dim,
+                          dim_size=dim_size, reduce='mean')
+            torch.clamp_(out, min_value, max_value)
+            out = torch.pow(out, 1/self.p)
+
+            if self.aggr == 'power_sum':
+                self.sigmoid_y = torch.sigmoid(self.y)
+                degrees = degree(index, num_nodes=dim_size).unsqueeze(1)
+                out = torch.pow(degrees, self.sigmoid_y) * out
+
+            return out
+
+        else:
+            raise NotImplementedError('To be implemented')
+
+
+class MsgNorm(torch.nn.Module):
+    def __init__(self, learn_msg_scale=False):
+        super(MsgNorm, self).__init__()
+
+        self.msg_scale = torch.nn.Parameter(torch.Tensor([1.0]),
+                                            requires_grad=learn_msg_scale)
+
+    def forward(self, x, msg, p=2):
+        msg = F.normalize(msg, p=p, dim=1)
+        x_norm = x.norm(p=p, dim=1, keepdim=True)
+        msg = msg * x_norm * self.msg_scale
+        return msg

gcn_lib/sparse/torch_nn.py

@@ -0,0 +1,160 @@
+import torch
+from torch import nn
+from torch.nn import Sequential as Seq, Linear as Lin
+from utils.data_util import get_atom_feature_dims, get_bond_feature_dims
+
+
+##############################
+#    Basic layers
+##############################
+def act_layer(act_type, inplace=False, neg_slope=0.2, n_prelu=1):
+    # activation layer
+    act = act_type.lower()
+    if act == 'relu':
+        layer = nn.ReLU(inplace)
+    elif act == 'leakyrelu':
+        layer = nn.LeakyReLU(neg_slope, inplace)
+    elif act == 'prelu':
+        layer = nn.PReLU(num_parameters=n_prelu, init=neg_slope)
+    else:
+        raise NotImplementedError('activation layer [%s] is not found' % act)
+    return layer
+
+
+def norm_layer(norm_type, nc):
+    # normalization layer 1d
+    norm = norm_type.lower()
+    if norm == 'batch':
+        layer = nn.BatchNorm1d(nc, affine=True)
+    elif norm == 'layer':
+        layer = nn.LayerNorm(nc, elementwise_affine=True)
+    elif norm == 'instance':
+        layer = nn.InstanceNorm1d(nc, affine=False)
+    else:
+        raise NotImplementedError('normalization layer [%s] is not found' % norm)
+    return layer
+
+
+class MultiSeq(Seq):
+    def __init__(self, *args):
+        super(MultiSeq, self).__init__(*args)
+
+    def forward(self, *inputs):
+        for module in self._modules.values():
+            if type(inputs) == tuple:
+                inputs = module(*inputs)
+            else:
+                inputs = module(inputs)
+        return inputs
+
+
+class MLP(Seq):
+    def __init__(self, channels, act='relu',
+                 norm=None, bias=True,
+                 drop=0., last_lin=False):
+        m = []
+
+        for i in range(1, len(channels)):
+
+            m.append(Lin(channels[i - 1], channels[i], bias))
+
+            if (i == len(channels) - 1) and last_lin:
+                pass
+            else:
+                if norm is not None and norm.lower() != 'none':
+                    m.append(norm_layer(norm, channels[i]))
+                if act is not None and act.lower() != 'none':
+                    m.append(act_layer(act))
+                if drop > 0:
+                    m.append(nn.Dropout2d(drop))
+
+        self.m = m
+        super(MLP, self).__init__(*self.m)
+
+
+class AtomEncoder(nn.Module):
+
+    def __init__(self, emb_dim):
+        super(AtomEncoder, self).__init__()
+
+        self.atom_embedding_list = nn.ModuleList()
+        full_atom_feature_dims = get_atom_feature_dims()
+
+        for i, dim in enumerate(full_atom_feature_dims):
+            emb = nn.Embedding(dim, emb_dim)
+            nn.init.xavier_uniform_(emb.weight.data)
+            self.atom_embedding_list.append(emb)
+
+    def forward(self, x):
+        x_embedding = 0
+        for i in range(x.shape[1]):
+            x_embedding += self.atom_embedding_list[i](x[:, i])
+
+        return x_embedding
+
+
+class BondEncoder(nn.Module):
+
+    def __init__(self, emb_dim):
+        super(BondEncoder, self).__init__()
+
+        self.bond_embedding_list = nn.ModuleList()
+        full_bond_feature_dims = get_bond_feature_dims()
+
+        for i, dim in enumerate(full_bond_feature_dims):
+            emb = nn.Embedding(dim, emb_dim)
+            nn.init.xavier_uniform_(emb.weight.data)
+            self.bond_embedding_list.append(emb)
+
+    def forward(self, edge_attr):
+        bond_embedding = 0
+        for i in range(edge_attr.shape[1]):
+            bond_embedding += self.bond_embedding_list[i](edge_attr[:, i])
+
+        return bond_embedding
+
+class MM_BondEncoder(nn.Module):
+    #Replaces de lookup in embedding module by one-hot-encoding 
+    # followed by matrix multiplication to allow Float type input 
+    # instead of Long type input (backpropagate through layer)
+
+    def __init__(self, emb_dim):
+        super(MM_BondEncoder, self).__init__()
+
+        self.bond_embedding_list = nn.ModuleList()
+        self.full_bond_feature_dims = get_bond_feature_dims()
+
+        for i, dim in enumerate(self.full_bond_feature_dims):
+            emb = nn.Linear(dim, emb_dim, bias=False)
+            nn.init.xavier_uniform_(emb.weight.data)
+            self.bond_embedding_list.append(emb)
+
+    def forward(self, edge_attr):
+        #Change each feature in edge_attr to one-hot-vector and embed
+        edge_attr1, edge_attr2, edge_attr3 = torch.split(edge_attr, self.full_bond_feature_dims, dim=1)
+        bond_embedding = self.bond_embedding_list[0](edge_attr1) + self.bond_embedding_list[1](edge_attr2) + self.bond_embedding_list[2](edge_attr3)
+        return bond_embedding
+
+class MM_AtomEncoder(nn.Module):
+    #Replaces de lookup in embedding module by one-hot-encoding 
+    # followed by matrix multiplication to allow Float type input 
+    # instead of Long type input (backpropagate through layer)
+
+    def __init__(self, emb_dim):
+        super(MM_AtomEncoder, self).__init__()
+
+        self.atom_embedding_list = nn.ModuleList()
+        self.full_atom_feature_dims = get_atom_feature_dims()
+
+        for i, dim in enumerate(self.full_atom_feature_dims):
+            emb = nn.Linear(dim, emb_dim, bias=False)
+            nn.init.xavier_uniform_(emb.weight.data)
+            self.atom_embedding_list.append(emb)
+
+    def forward(self, x):
+        #Change each feature in edge_attr to one-hot-vector and embed
+        split = torch.split(x, self.full_atom_feature_dims, dim=1)
+        atom_embedding = 0
+        for i in range(len(self.full_atom_feature_dims)):
+            atom_embedding += self.atom_embedding_list[i](split[i])
+        return atom_embedding

gcn_lib/sparse/torch_vertex.py

@@ -0,0 +1,355 @@
+import torch
+from torch import nn
+import torch.nn.functional as F
+import torch_geometric as tg
+from .torch_nn import MLP, act_layer, norm_layer, BondEncoder, MM_BondEncoder
+from .torch_edge import DilatedKnnGraph
+from .torch_message import GenMessagePassing, MsgNorm
+from torch_geometric.utils import remove_self_loops, add_self_loops
+
+
+class GENConv(GenMessagePassing):
+    """
+     GENeralized Graph Convolution (GENConv): https://arxiv.org/pdf/2006.07739.pdf
+     SoftMax  &  PowerMean Aggregation
+    """
+    def __init__(self, in_dim, emb_dim, args,
+                 aggr='softmax',
+                 t=1.0, learn_t=False,
+                 p=1.0, learn_p=False,
+                 y=0.0, learn_y=False,
+                 msg_norm=False, learn_msg_scale=True,
+                 encode_edge=False, bond_encoder=False,
+                 edge_feat_dim=None,
+                 norm='batch', mlp_layers=2,
+                 eps=1e-7):
+
+        super(GENConv, self).__init__(aggr=aggr,
+                                      t=t, learn_t=learn_t,
+                                      p=p, learn_p=learn_p, 
+                                      y=y, learn_y=learn_y)
+
+        channels_list = [in_dim]
+
+        for i in range(mlp_layers-1):
+            channels_list.append(in_dim*2)
+
+        channels_list.append(emb_dim)
+
+        self.mlp = MLP(channels=channels_list,
+                       norm=norm,
+                       last_lin=True)
+
+        self.msg_encoder = torch.nn.ReLU()
+        self.eps = eps
+
+        self.msg_norm = msg_norm
+        self.encode_edge = encode_edge
+        self.bond_encoder = bond_encoder
+        self.advs = args.advs
+        if msg_norm:
+            self.msg_norm = MsgNorm(learn_msg_scale=learn_msg_scale)
+        else:
+            self.msg_norm = None
+
+        if self.encode_edge:
+            if self.bond_encoder:
+                if self.advs:
+                    self.edge_encoder = MM_BondEncoder(emb_dim=in_dim)
+                else:
+                    self.edge_encoder = BondEncoder(emb_dim=in_dim)
+            else:
+                self.edge_encoder = torch.nn.Linear(edge_feat_dim, in_dim)
+
+    def forward(self, x, edge_index, edge_attr=None):
+        x = x
+
+        if self.encode_edge and edge_attr is not None:
+            edge_emb = self.edge_encoder(edge_attr)
+        else:
+            edge_emb = edge_attr
+
+        m = self.propagate(edge_index, x=x, edge_attr=edge_emb)
+
+        if self.msg_norm is not None:
+            m = self.msg_norm(x, m)
+
+        h = x + m
+        out = self.mlp(h)
+
+        return out
+
+    def message(self, x_j, edge_attr=None):
+
+        if edge_attr is not None:
+            msg = x_j + edge_attr
+        else:
+            msg = x_j
+
+        return self.msg_encoder(msg) + self.eps
+
+    def update(self, aggr_out):
+        return aggr_out
+
+
+class MRConv(nn.Module):
+    """
+    Max-Relative Graph Convolution (Paper: https://arxiv.org/abs/1904.03751)
+    """
+    def __init__(self, in_channels, out_channels, act='relu', norm=None, bias=True, aggr='max'):
+        super(MRConv, self).__init__()
+        self.nn = MLP([in_channels*2, out_channels], act, norm, bias)
+        self.aggr = aggr
+
+    def forward(self, x, edge_index):
+        """"""
+        x_j = tg.utils.scatter_(self.aggr, torch.index_select(x, 0, edge_index[0]) - torch.index_select(x, 0, edge_index[1]), edge_index[1], dim_size=x.shape[0])
+        return self.nn(torch.cat([x, x_j], dim=1))
+
+
+class EdgConv(tg.nn.EdgeConv):
+    """
+    Edge convolution layer (with activation, batch normalization)
+    """
+    def __init__(self, in_channels, out_channels, act='relu', norm=None, bias=True, aggr='max'):
+        super(EdgConv, self).__init__(MLP([in_channels*2, out_channels], act, norm, bias), aggr)
+
+    def forward(self, x, edge_index):
+        return super(EdgConv, self).forward(x, edge_index)
+
+
+class GATConv(nn.Module):
+    """
+    Graph Attention Convolution layer (with activation, batch normalization)
+    """
+    def __init__(self, in_channels, out_channels,  act='relu', norm=None, bias=True, heads=8):
+        super(GATConv, self).__init__()
+        self.gconv = tg.nn.GATConv(in_channels, out_channels, heads, bias=bias)
+        m =[]
+        if act:
+            m.append(act_layer(act))
+        if norm:
+            m.append(norm_layer(norm, out_channels))
+        self.unlinear = nn.Sequential(*m)
+
+    def forward(self, x, edge_index):
+        out = self.unlinear(self.gconv(x, edge_index))
+        return out
+
+
+class SAGEConv(tg.nn.SAGEConv):
+    r"""The GraphSAGE operator from the `"Inductive Representation Learning on
+    Large Graphs" <https://arxiv.org/abs/1706.02216>`_ paper
+
+    .. math::
+        \mathbf{\hat{x}}_i &= \mathbf{\Theta} \cdot
+        \mathrm{mean}_{j \in \mathcal{N(i) \cup \{ i \}}}(\mathbf{x}_j)
+
+        \mathbf{x}^{\prime}_i &= \frac{\mathbf{\hat{x}}_i}
+        {\| \mathbf{\hat{x}}_i \|_2}.
+
+    Args:
+        in_channels (int): Size of each input sample.
+        out_channels (int): Size of each output sample.
+        normalize (bool, optional): If set to :obj:`False`, output features
+            will not be :math:`\ell_2`-normalized. (default: :obj:`True`)
+        bias (bool, optional): If set to :obj:`False`, the layer will not learn
+            an additive bias. (default: :obj:`True`)
+        **kwargs (optional): Additional arguments of
+            :class:`torch_geometric.nn.conv.MessagePassing`.
+    """
+
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 nn,
+                 norm=True,
+                 bias=True,
+                 relative=False,
+                 **kwargs):
+        self.relative = relative
+        if norm is not None:
+            super(SAGEConv, self).__init__(in_channels, out_channels, True, bias, **kwargs)
+        else:
+            super(SAGEConv, self).__init__(in_channels, out_channels, False, bias, **kwargs)
+        self.nn = nn
+
+    def forward(self, x, edge_index, size=None):
+        """"""
+        if size is None:
+            edge_index, _ = remove_self_loops(edge_index)
+            edge_index, _ = add_self_loops(edge_index, num_nodes=x.size(0))
+
+        x = x.unsqueeze(-1) if x.dim() == 1 else x
+        return self.propagate(edge_index, size=size, x=x)
+
+    def message(self, x_i, x_j):
+        if self.relative:
+            x = torch.matmul(x_j - x_i, self.weight)
+        else:
+            x = torch.matmul(x_j, self.weight)
+        return x
+
+    def update(self, aggr_out, x):
+        out = self.nn(torch.cat((x, aggr_out), dim=1))
+        if self.bias is not None:
+            out = out + self.bias
+        if self.normalize:
+            out = F.normalize(out, p=2, dim=-1)
+        return out
+
+
+class RSAGEConv(SAGEConv):
+    """
+    Residual SAGE convolution layer (with activation, batch normalization)
+    """
+
+    def __init__(self, in_channels, out_channels, act='relu', norm=None, bias=True, relative=False):
+        nn = MLP([out_channels + in_channels, out_channels], act, norm, bias)
+        super(RSAGEConv, self).__init__(in_channels, out_channels, nn, norm, bias, relative)
+
+
+class SemiGCNConv(nn.Module):
+    """
+    SemiGCN convolution layer (with activation, batch normalization)
+    """
+
+    def __init__(self, in_channels, out_channels, act='relu', norm=None, bias=True):
+        super(SemiGCNConv, self).__init__()
+        self.gconv = tg.nn.GCNConv(in_channels, out_channels, bias=bias)
+        m = []
+        if act:
+            m.append(act_layer(act))
+        if norm:
+            m.append(norm_layer(norm, out_channels))
+        self.unlinear = nn.Sequential(*m)
+
+    def forward(self, x, edge_index):
+        out = self.unlinear(self.gconv(x, edge_index))
+        return out
+
+
+class GinConv(tg.nn.GINConv):
+    """
+    GINConv layer (with activation, batch normalization)
+    """
+    def __init__(self, in_channels, out_channels, act='relu', norm=None, bias=True, aggr='add'):
+        super(GinConv, self).__init__(MLP([in_channels, out_channels], act, norm, bias))
+
+    def forward(self, x, edge_index):
+        return super(GinConv, self).forward(x, edge_index)
+
+
+class GraphConv(nn.Module):
+    """
+    Static graph convolution layer
+    """
+    def __init__(self, in_channels, out_channels, conv='edge',
+                 act='relu', norm=None, bias=True, heads=8):
+        super(GraphConv, self).__init__()
+        if conv.lower() == 'edge':
+            self.gconv = EdgConv(in_channels, out_channels, act, norm, bias)
+        elif conv.lower() == 'mr':
+            self.gconv = MRConv(in_channels, out_channels, act, norm, bias)
+        elif conv.lower() == 'gat':
+            self.gconv = GATConv(in_channels, out_channels//heads, act, norm, bias, heads)
+        elif conv.lower() == 'gcn':
+            self.gconv = SemiGCNConv(in_channels, out_channels, act, norm, bias)
+        elif conv.lower() == 'gin':
+            self.gconv = GinConv(in_channels, out_channels, act, norm, bias)
+        elif conv.lower() == 'sage':
+            self.gconv = RSAGEConv(in_channels, out_channels, act, norm, bias, False)
+        elif conv.lower() == 'rsage':
+            self.gconv = RSAGEConv(in_channels, out_channels, act, norm, bias, True)
+        else:
+            raise NotImplementedError('conv {} is not implemented'.format(conv))
+
+    def forward(self, x, edge_index):
+        return self.gconv(x, edge_index)
+
+
+class DynConv(GraphConv):
+    """
+    Dynamic graph convolution layer
+    """
+    def __init__(self, in_channels, out_channels, kernel_size=9, dilation=1, conv='edge', act='relu',
+                 norm=None, bias=True, heads=8, **kwargs):
+        super(DynConv, self).__init__(in_channels, out_channels, conv, act, norm, bias, heads)
+        self.k = kernel_size
+        self.d = dilation
+        self.dilated_knn_graph = DilatedKnnGraph(kernel_size, dilation, **kwargs)
+
+    def forward(self, x, batch=None):
+        edge_index = self.dilated_knn_graph(x, batch)
+        return super(DynConv, self).forward(x, edge_index)
+
+
+class PlainDynBlock(nn.Module):
+    """
+    Plain Dynamic graph convolution block
+    """
+    def __init__(self, channels,  kernel_size=9, dilation=1, conv='edge', act='relu', norm=None,
+                 bias=True, res_scale=1, **kwargs):
+        super(PlainDynBlock, self).__init__()
+        self.body = DynConv(channels, channels, kernel_size, dilation, conv,
+                            act, norm, bias, **kwargs)
+        self.res_scale = res_scale
+
+    def forward(self, x, batch=None):
+        return self.body(x, batch), batch
+
+
+class ResDynBlock(nn.Module):
+    """
+    Residual Dynamic graph convolution block
+    """
+    def __init__(self, channels,  kernel_size=9, dilation=1, conv='edge', act='relu', norm=None,
+                 bias=True, res_scale=1, **kwargs):
+        super(ResDynBlock, self).__init__()
+        self.body = DynConv(channels, channels, kernel_size, dilation, conv,
+                            act, norm, bias, **kwargs)
+        self.res_scale = res_scale
+
+    def forward(self, x, batch=None):
+        return self.body(x, batch) + x*self.res_scale, batch
+
+
+class DenseDynBlock(nn.Module):
+    """
+    Dense Dynamic graph convolution block
+    """
+    def __init__(self, in_channels, out_channels=64, kernel_size=9, dilation=1, conv='edge', act='relu', norm=None, bias=True, **kwargs):
+        super(DenseDynBlock, self).__init__()
+        self.body = DynConv(in_channels, out_channels, kernel_size, dilation, conv,
+                            act, norm, bias, **kwargs)
+
+    def forward(self, x, batch=None):
+        dense = self.body(x, batch)
+        return torch.cat((x, dense), 1), batch
+
+
+class ResGraphBlock(nn.Module):
+    """
+    Residual Static graph convolution block
+    """
+    def __init__(self, channels,  conv='edge', act='relu', norm=None, bias=True, heads=8,  res_scale=1):
+        super(ResGraphBlock, self).__init__()
+        self.body = GraphConv(channels, channels, conv, act, norm, bias, heads)
+        self.res_scale = res_scale
+
+    def forward(self, x, edge_index):
+        return self.body(x, edge_index) + x*self.res_scale, edge_index
+
+
+class DenseGraphBlock(nn.Module):
+    """
+    Dense Static graph convolution block
+    """
+    def __init__(self, in_channels,  out_channels, conv='edge', act='relu', norm=None, bias=True, heads=8):
+        super(DenseGraphBlock, self).__init__()
+        self.body = GraphConv(in_channels, out_channels, conv, act, norm, bias, heads)
+
+    def forward(self, x, edge_index):
+        dense = self.body(x, edge_index)
+        return torch.cat((x, dense), 1), edge_index
+

gradio/title.md

@@ -0,0 +1,19 @@
+<div>
+  <div>
+    <div style="display: flex; justify-content: center; align-items: center; text-align: center; font-size: 40px;">
+      <b>⚛️ PLA-Net</b>
+    </div>
+    <br>
+    <div style="display: flex; justify-content: center; align-items: center; text-align: center;">
+        <a href="#"><img src="https://img.shields.io/static/v1?label=11.6&message=CUDA&color=green"></a> &ensp;
+        <a href="#"><img src="https://img.shields.io/static/v1?label=1.12.0&message=Pytorch&color=red"></a> &ensp;
+        <a href="https://github.com/juliocesar-io/PLA-Net"><img src="https://img.shields.io/static/v1?logo=github&label=Github&message=Fork"></a>
+    </div>
+    <br>
+    <div style="justify-content: center; align-items: center; text-align: center; font-size: 14px;">
+        <p>
+              Run Inference of PLA-Net for a single protein in the  and multiple ligands to predict the binding affinities using Graph Neural Networks. 
+        </p>
+    </div>
+  </div>
+</div>

model/__init__.py

@@ -0,0 +1,4 @@
+import sys
+import os
+ROOT_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+sys.path.append(ROOT_DIR)

model/model.py

@@ -0,0 +1,246 @@
+import torch
+import torch.nn.functional as F
+from torch_geometric.nn import global_add_pool, global_mean_pool, global_max_pool
+
+from gcn_lib.sparse.torch_vertex import GENConv
+from gcn_lib.sparse.torch_nn import norm_layer, MLP, MM_AtomEncoder
+
+from model.model_encoder import AtomEncoder, BondEncoder
+
+import logging
+
+
+class DeeperGCN(torch.nn.Module):
+    def __init__(self, args, is_prot=False, saliency=False):
+        super(DeeperGCN, self).__init__()
+
+        # Set PM configuration
+        if is_prot:
+            self.num_layers = args.num_layers_prot
+            mlp_layers = args.mlp_layers_prot
+            hidden_channels = args.hidden_channels_prot
+            self.msg_norm = args.msg_norm_prot
+            learn_msg_scale = args.learn_msg_scale_prot
+            self.conv_encode_edge = args.conv_encode_edge_prot
+
+        # Set LM configuration
+        else:
+            self.num_layers = args.num_layers
+            mlp_layers = args.mlp_layers
+            hidden_channels = args.hidden_channels
+            self.msg_norm = args.msg_norm
+            learn_msg_scale = args.learn_msg_scale
+            self.conv_encode_edge = args.conv_encode_edge
+
+        # Set overall model configuration
+        self.dropout = args.dropout
+        self.block = args.block
+        self.add_virtual_node = args.add_virtual_node
+        self.training = True
+        self.args = args
+
+        num_classes = args.nclasses
+        conv = args.conv
+        aggr = args.gcn_aggr
+        t = args.t
+        self.learn_t = args.learn_t
+        p = args.p
+        self.learn_p = args.learn_p
+
+        norm = args.norm
+
+        graph_pooling = args.graph_pooling
+
+        # Print model parameters
+        print(
+            "The number of layers {}".format(self.num_layers),
+            "Aggr aggregation method {}".format(aggr),
+            "block: {}".format(self.block),
+        )
+        if self.block == "res+":
+            print("LN/BN->ReLU->GraphConv->Res")
+        elif self.block == "res":
+            print("GraphConv->LN/BN->ReLU->Res")
+        elif self.block == "dense":
+            raise NotImplementedError("To be implemented")
+        elif self.block == "plain":
+            print("GraphConv->LN/BN->ReLU")
+        else:
+            raise Exception("Unknown block Type")
+
+        self.gcns = torch.nn.ModuleList()
+        self.norms = torch.nn.ModuleList()
+
+        if self.add_virtual_node:
+            self.virtualnode_embedding = torch.nn.Embedding(1, hidden_channels)
+            torch.nn.init.constant_(self.virtualnode_embedding.weight.data, 0)
+
+            self.mlp_virtualnode_list = torch.nn.ModuleList()
+
+            for layer in range(self.num_layers - 1):
+                self.mlp_virtualnode_list.append(MLP([hidden_channels] * 3, norm=norm))
+
+        # Set GCN layer configuration
+        for layer in range(self.num_layers):
+            if conv == "gen":
+                gcn = GENConv(
+                    hidden_channels,
+                    hidden_channels,
+                    args,
+                    aggr=aggr,
+                    t=t,
+                    learn_t=self.learn_t,
+                    p=p,
+                    learn_p=self.learn_p,
+                    msg_norm=self.msg_norm,
+                    learn_msg_scale=learn_msg_scale,
+                    encode_edge=self.conv_encode_edge,
+                    bond_encoder=True,
+                    norm=norm,
+                    mlp_layers=mlp_layers,
+                )
+            else:
+                raise Exception("Unknown Conv Type")
+            self.gcns.append(gcn)
+            self.norms.append(norm_layer(norm, hidden_channels))
+
+        # Set embbeding layers
+        self.atom_encoder = AtomEncoder(emb_dim=hidden_channels)
+
+        if saliency:
+            self.atom_encoder = MM_AtomEncoder(emb_dim=hidden_channels)
+        else:
+            self.atom_encoder = AtomEncoder(emb_dim=hidden_channels)
+
+        if not self.conv_encode_edge:
+            self.bond_encoder = BondEncoder(emb_dim=hidden_channels)
+
+        # Set type of pooling
+        if graph_pooling == "sum":
+            self.pool = global_add_pool
+        elif graph_pooling == "mean":
+            self.pool = global_mean_pool
+        elif graph_pooling == "max":
+            self.pool = global_max_pool
+        else:
+            raise Exception("Unknown Pool Type")
+
+        # Set classification layer
+        self.graph_pred_linear = torch.nn.Linear(hidden_channels, num_classes)
+
+    def forward(self, input_batch, dropout=True, embeddings=False):
+
+        x = input_batch.x
+        edge_index = input_batch.edge_index
+        edge_attr = input_batch.edge_attr
+        batch = input_batch.batch
+
+        h = self.atom_encoder(x)
+
+        if self.add_virtual_node:
+            virtualnode_embedding = self.virtualnode_embedding(
+                torch.zeros(batch[-1].item() + 1)
+                .to(edge_index.dtype)
+                .to(edge_index.device)
+            )
+            h = h + virtualnode_embedding[batch]
+
+        if self.conv_encode_edge:
+            edge_emb = edge_attr
+        else:
+            edge_emb = self.bond_encoder(edge_attr)
+
+        if self.block == "res+":
+
+            h = self.gcns[0](h, edge_index, edge_emb)
+
+            for layer in range(1, self.num_layers):
+                h1 = self.norms[layer - 1](h)
+                h2 = F.relu(h1)
+                if dropout:
+                    h2 = F.dropout(h2, p=self.dropout, training=self.training)
+
+                if self.add_virtual_node:
+                    virtualnode_embedding_temp = (
+                        global_add_pool(h2, batch) + virtualnode_embedding
+                    )
+                    if dropout:
+                        virtualnode_embedding = F.dropout(
+                            self.mlp_virtualnode_list[layer - 1](
+                                virtualnode_embedding_temp
+                            ),
+                            self.dropout,
+                            training=self.training,
+                        )
+
+                    h2 = h2 + virtualnode_embedding[batch]
+
+                h = self.gcns[layer](h2, edge_index, edge_emb) + h
+
+            h = self.norms[self.num_layers - 1](h)
+            if dropout:
+                h = F.dropout(h, p=self.dropout, training=self.training)
+
+        elif self.block == "res":
+
+            h = F.relu(self.norms[0](self.gcns[0](h, edge_index, edge_emb)))
+            h = F.dropout(h, p=self.dropout, training=self.training)
+
+            for layer in range(1, self.num_layers):
+                h1 = self.gcns[layer](h, edge_index, edge_emb)
+                h2 = self.norms[layer](h1)
+                h = F.relu(h2) + h
+                h = F.dropout(h, p=self.dropout, training=self.training)
+
+        elif self.block == "dense":
+            raise NotImplementedError("To be implemented")
+
+        elif self.block == "plain":
+
+            h = F.relu(self.norms[0](self.gcns[0](h, edge_index, edge_emb)))
+            h = F.dropout(h, p=self.dropout, training=self.training)
+
+            for layer in range(1, self.num_layers):
+                h1 = self.gcns[layer](h, edge_index, edge_emb)
+                h2 = self.norms[layer](h1)
+                if layer != (self.num_layers - 1):
+                    h = F.relu(h2)
+                else:
+                    h = h2
+                h = F.dropout(h, p=self.dropout, training=self.training)
+        else:
+            raise Exception("Unknown block Type")
+
+        h_graph = self.pool(h, batch)
+
+        if self.args.use_prot or embeddings:
+            return h_graph
+        else:
+            return self.graph_pred_linear(h_graph)
+
+    def print_params(self, epoch=None, final=False):
+
+        if self.learn_t:
+            ts = []
+            for gcn in self.gcns:
+                ts.append(gcn.t.item())
+            if final:
+                print("Final t {}".format(ts))
+            else:
+                logging.info("Epoch {}, t {}".format(epoch, ts))
+        if self.learn_p:
+            ps = []
+            for gcn in self.gcns:
+                ps.append(gcn.p.item())
+            if final:
+                print("Final p {}".format(ps))
+            else:
+                logging.info("Epoch {}, p {}".format(epoch, ps))
+        if self.msg_norm:
+            ss = []
+            for gcn in self.gcns:
+                ss.append(gcn.msg_norm.msg_scale.item())
+            if final:
+                print("Final s {}".format(ss))
+            else:
+                logging.info("Epoch {}, s {}".format(epoch, ss))

model/model_concatenation.py

@@ -0,0 +1,92 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from gcn_lib.sparse.torch_nn import MLP
+
+from model.model import DeeperGCN
+
+import numpy as np
+import logging
+
+
+class PLANet(torch.nn.Module):
+    def __init__(self, args,saliency=False):
+        super(PLANet, self).__init__() 
+
+        # Args
+        self.args = args
+        # Molecule and protein networks
+        self.molecule_gcn = DeeperGCN(args, saliency=saliency)
+        self.target_gcn = DeeperGCN(args, is_prot=True)
+
+        # Individual modules' final embbeding size
+        output_molecule = args.hidden_channels
+        output_protein = args.hidden_channels_prot
+        # Concatenated embbeding size
+        Final_output = output_molecule + output_protein
+        # Overall model's final embbeding size
+        hidden_channels = args.hidden_channels
+
+        # Multiplier
+        if args.multi_concat:
+            self.multiplier_prot = torch.nn.Parameter(torch.zeros(hidden_channels))
+            self.multiplier_ligand = torch.nn.Parameter(torch.ones(hidden_channels))
+        elif self.args.MLP:
+            # MLP
+            hidden_channel = 64
+            channels_concat = [256, hidden_channel, hidden_channel, 128]
+            self.concatenation_gcn = MLP(channels_concat, norm=args.norm, last_lin=True)
+            # breakpoint()
+            indices = np.diag_indices(hidden_channel)
+            tensor_linear_layer = torch.zeros(hidden_channel, Final_output)
+            tensor_linear_layer[indices[0], indices[1]] = 1
+            self.concatenation_gcn[0].weight = torch.nn.Parameter(tensor_linear_layer)
+            self.concatenation_gcn[0].bias = torch.nn.Parameter(
+                torch.zeros(hidden_channel)
+            )
+        else:
+            # Concatenation Layer
+            self.concatenation_gcn = nn.Linear(Final_output, hidden_channels)
+            indices = np.diag_indices(output_molecule)
+            tensor_linear_layer = torch.zeros(hidden_channels, Final_output)
+            tensor_linear_layer[indices[0], indices[1]] = 1
+            self.concatenation_gcn.weight = torch.nn.Parameter(tensor_linear_layer)
+            self.concatenation_gcn.bias = torch.nn.Parameter(
+                torch.zeros(hidden_channels)
+            )
+
+        # Classification Layer
+        num_classes = args.nclasses
+        self.classification = nn.Linear(hidden_channels, num_classes)
+
+    def forward(self, molecule, target):
+
+        molecule_features = self.molecule_gcn(molecule)
+        target_features = self.target_gcn(target)
+        # Multiplier
+        if self.args.multi_concat:
+            All_features = (
+                target_features * self.multiplier_prot
+                + molecule_features * self.multiplier_ligand
+            )
+        else:
+            # Concatenation of LM and PM modules
+            All_features = torch.cat((molecule_features, target_features), dim=1)
+            All_features = self.concatenation_gcn(All_features)
+        # Classification
+        classification = self.classification(All_features)
+
+        return classification
+
+    def print_params(self, epoch=None, final=False):
+
+        logging.info("======= Molecule GCN ========")
+        self.molecule_gcn.print_params(epoch)
+        logging.info("======= Protein GCN ========")
+        self.target_gcn.print_params(epoch)
+        if self.args.multi_concat:
+            sum_prot_multi = sum(self.multiplier_prot)
+            sum_lig_multi = sum(self.multiplier_ligand)
+            logging.info("Sumed prot multi: {}".format(sum_prot_multi))
+            logging.info("Sumed lig multi: {}".format(sum_lig_multi))

model/model_encoder.py

@@ -0,0 +1,54 @@
+import torch
+from data.features import get_atom_feature_dims, get_bond_feature_dims 
+
+full_atom_feature_dims = get_atom_feature_dims()
+full_bond_feature_dims = get_bond_feature_dims()
+
+class AtomEncoder(torch.nn.Module):
+
+    def __init__(self, emb_dim):
+        super(AtomEncoder, self).__init__()
+        
+        self.atom_embedding_list = torch.nn.ModuleList()
+
+        for i, dim in enumerate(full_atom_feature_dims):
+            emb = torch.nn.Embedding(dim, emb_dim)
+            torch.nn.init.xavier_uniform_(emb.weight.data)
+            self.atom_embedding_list.append(emb)
+
+    def forward(self, x):
+        x_embedding = 0
+        for i in range(x.shape[1]):
+            x_embedding += self.atom_embedding_list[i](x[:,i])
+
+        return x_embedding
+
+
+class BondEncoder(torch.nn.Module):
+    
+    def __init__(self, emb_dim):
+        super(BondEncoder, self).__init__()
+        
+        self.bond_embedding_list = torch.nn.ModuleList()
+
+        for i, dim in enumerate(full_bond_feature_dims):
+            emb = torch.nn.Embedding(dim, emb_dim)
+            torch.nn.init.xavier_uniform_(emb.weight.data)
+            self.bond_embedding_list.append(emb)
+
+    def forward(self, edge_attr):
+        bond_embedding = 0
+        for i in range(edge_attr.shape[1]):
+            bond_embedding += self.bond_embedding_list[i](edge_attr[:,i])
+
+        return bond_embedding   
+
+
+if __name__ == '__main__':
+    from loader import GraphClassificationPygDataset
+    dataset = GraphClassificationPygDataset(name = 'tox21')
+    atom_enc = AtomEncoder(100)
+    bond_enc = BondEncoder(100)
+
+    print(atom_enc(dataset[0].x))
+    print(bond_enc(dataset[0].edge_attr))

pretrained-models/BINARY_ada/Fold1/Best_Model.pth

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

pretrained-models/BINARY_ada/Fold2/Best_Model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70bd05db3d218f477792f56f681f09e571f817298c1d2f94c4b8f5c850725a88
+size 22506847

pretrained-models/BINARY_ada/Fold3/Best_Model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2dbfbe976cb712448f80eb354d45670c37c4d67c6949f80cfd9ce8c2716fdc9b
+size 22505567

pretrained-models/BINARY_ada/Fold4/Best_Model.pth

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

requirements.txt

@@ -0,0 +1,9 @@
+rdkit-pypi==2021.9.3
+modlamp==4.3.0
+ogb==1.3.6 
+tqdm==4.63.0
+h5py==3.11.0
+scipy==1.9.0
+numpy==1.24.4
+gradio==4.43.0
+fastapi==0.112.4

scripts/model/__init__.py

@@ -0,0 +1,4 @@
+import sys
+import os
+ROOT_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+sys.path.append(ROOT_DIR)

scripts/model/model.py

@@ -0,0 +1,246 @@
+import torch
+import torch.nn.functional as F
+from torch_geometric.nn import global_add_pool, global_mean_pool, global_max_pool
+
+from gcn_lib.sparse.torch_vertex import GENConv
+from gcn_lib.sparse.torch_nn import norm_layer, MLP, MM_AtomEncoder
+
+from model.model_encoder import AtomEncoder, BondEncoder
+
+import logging
+
+
+class DeeperGCN(torch.nn.Module):
+    def __init__(self, args, is_prot=False, saliency=False):
+        super(DeeperGCN, self).__init__()
+
+        # Set PM configuration
+        if is_prot:
+            self.num_layers = args.num_layers_prot
+            mlp_layers = args.mlp_layers_prot
+            hidden_channels = args.hidden_channels_prot
+            self.msg_norm = args.msg_norm_prot
+            learn_msg_scale = args.learn_msg_scale_prot
+            self.conv_encode_edge = args.conv_encode_edge_prot
+
+        # Set LM configuration
+        else:
+            self.num_layers = args.num_layers
+            mlp_layers = args.mlp_layers
+            hidden_channels = args.hidden_channels
+            self.msg_norm = args.msg_norm
+            learn_msg_scale = args.learn_msg_scale
+            self.conv_encode_edge = args.conv_encode_edge
+
+        # Set overall model configuration
+        self.dropout = args.dropout
+        self.block = args.block
+        self.add_virtual_node = args.add_virtual_node
+        self.training = True
+        self.args = args
+
+        num_classes = args.nclasses
+        conv = args.conv
+        aggr = args.gcn_aggr
+        t = args.t
+        self.learn_t = args.learn_t
+        p = args.p
+        self.learn_p = args.learn_p
+
+        norm = args.norm
+
+        graph_pooling = args.graph_pooling
+
+        # Print model parameters
+        print(
+            "The number of layers {}".format(self.num_layers),
+            "Aggr aggregation method {}".format(aggr),
+            "block: {}".format(self.block),
+        )
+        if self.block == "res+":
+            print("LN/BN->ReLU->GraphConv->Res")
+        elif self.block == "res":
+            print("GraphConv->LN/BN->ReLU->Res")
+        elif self.block == "dense":
+            raise NotImplementedError("To be implemented")
+        elif self.block == "plain":
+            print("GraphConv->LN/BN->ReLU")
+        else:
+            raise Exception("Unknown block Type")
+
+        self.gcns = torch.nn.ModuleList()
+        self.norms = torch.nn.ModuleList()
+
+        if self.add_virtual_node:
+            self.virtualnode_embedding = torch.nn.Embedding(1, hidden_channels)
+            torch.nn.init.constant_(self.virtualnode_embedding.weight.data, 0)
+
+            self.mlp_virtualnode_list = torch.nn.ModuleList()
+
+            for layer in range(self.num_layers - 1):
+                self.mlp_virtualnode_list.append(MLP([hidden_channels] * 3, norm=norm))
+
+        # Set GCN layer configuration
+        for layer in range(self.num_layers):
+            if conv == "gen":
+                gcn = GENConv(
+                    hidden_channels,
+                    hidden_channels,
+                    args,
+                    aggr=aggr,
+                    t=t,
+                    learn_t=self.learn_t,
+                    p=p,
+                    learn_p=self.learn_p,
+                    msg_norm=self.msg_norm,
+                    learn_msg_scale=learn_msg_scale,
+                    encode_edge=self.conv_encode_edge,
+                    bond_encoder=True,
+                    norm=norm,
+                    mlp_layers=mlp_layers,
+                )
+            else:
+                raise Exception("Unknown Conv Type")
+            self.gcns.append(gcn)
+            self.norms.append(norm_layer(norm, hidden_channels))
+
+        # Set embbeding layers
+        self.atom_encoder = AtomEncoder(emb_dim=hidden_channels)
+
+        if saliency:
+            self.atom_encoder = MM_AtomEncoder(emb_dim=hidden_channels)
+        else:
+            self.atom_encoder = AtomEncoder(emb_dim=hidden_channels)
+
+        if not self.conv_encode_edge:
+            self.bond_encoder = BondEncoder(emb_dim=hidden_channels)
+
+        # Set type of pooling
+        if graph_pooling == "sum":
+            self.pool = global_add_pool
+        elif graph_pooling == "mean":
+            self.pool = global_mean_pool
+        elif graph_pooling == "max":
+            self.pool = global_max_pool
+        else:
+            raise Exception("Unknown Pool Type")
+
+        # Set classification layer
+        self.graph_pred_linear = torch.nn.Linear(hidden_channels, num_classes)
+
+    def forward(self, input_batch, dropout=True, embeddings=False):
+
+        x = input_batch.x
+        edge_index = input_batch.edge_index
+        edge_attr = input_batch.edge_attr
+        batch = input_batch.batch
+
+        h = self.atom_encoder(x)
+
+        if self.add_virtual_node:
+            virtualnode_embedding = self.virtualnode_embedding(
+                torch.zeros(batch[-1].item() + 1)
+                .to(edge_index.dtype)
+                .to(edge_index.device)
+            )
+            h = h + virtualnode_embedding[batch]
+
+        if self.conv_encode_edge:
+            edge_emb = edge_attr
+        else:
+            edge_emb = self.bond_encoder(edge_attr)
+
+        if self.block == "res+":
+
+            h = self.gcns[0](h, edge_index, edge_emb)
+
+            for layer in range(1, self.num_layers):
+                h1 = self.norms[layer - 1](h)
+                h2 = F.relu(h1)
+                if dropout:
+                    h2 = F.dropout(h2, p=self.dropout, training=self.training)
+
+                if self.add_virtual_node:
+                    virtualnode_embedding_temp = (
+                        global_add_pool(h2, batch) + virtualnode_embedding
+                    )
+                    if dropout:
+                        virtualnode_embedding = F.dropout(
+                            self.mlp_virtualnode_list[layer - 1](
+                                virtualnode_embedding_temp
+                            ),
+                            self.dropout,
+                            training=self.training,
+                        )
+
+                    h2 = h2 + virtualnode_embedding[batch]
+
+                h = self.gcns[layer](h2, edge_index, edge_emb) + h
+
+            h = self.norms[self.num_layers - 1](h)
+            if dropout:
+                h = F.dropout(h, p=self.dropout, training=self.training)
+
+        elif self.block == "res":
+
+            h = F.relu(self.norms[0](self.gcns[0](h, edge_index, edge_emb)))
+            h = F.dropout(h, p=self.dropout, training=self.training)
+
+            for layer in range(1, self.num_layers):
+                h1 = self.gcns[layer](h, edge_index, edge_emb)
+                h2 = self.norms[layer](h1)
+                h = F.relu(h2) + h
+                h = F.dropout(h, p=self.dropout, training=self.training)
+
+        elif self.block == "dense":
+            raise NotImplementedError("To be implemented")
+
+        elif self.block == "plain":
+
+            h = F.relu(self.norms[0](self.gcns[0](h, edge_index, edge_emb)))
+            h = F.dropout(h, p=self.dropout, training=self.training)
+
+            for layer in range(1, self.num_layers):
+                h1 = self.gcns[layer](h, edge_index, edge_emb)
+                h2 = self.norms[layer](h1)
+                if layer != (self.num_layers - 1):
+                    h = F.relu(h2)
+                else:
+                    h = h2
+                h = F.dropout(h, p=self.dropout, training=self.training)
+        else:
+            raise Exception("Unknown block Type")
+
+        h_graph = self.pool(h, batch)
+
+        if self.args.use_prot or embeddings:
+            return h_graph
+        else:
+            return self.graph_pred_linear(h_graph)
+
+    def print_params(self, epoch=None, final=False):
+
+        if self.learn_t:
+            ts = []
+            for gcn in self.gcns:
+                ts.append(gcn.t.item())
+            if final:
+                print("Final t {}".format(ts))
+            else:
+                logging.info("Epoch {}, t {}".format(epoch, ts))
+        if self.learn_p:
+            ps = []
+            for gcn in self.gcns:
+                ps.append(gcn.p.item())
+            if final:
+                print("Final p {}".format(ps))
+            else:
+                logging.info("Epoch {}, p {}".format(epoch, ps))
+        if self.msg_norm:
+            ss = []
+            for gcn in self.gcns:
+                ss.append(gcn.msg_norm.msg_scale.item())
+            if final:
+                print("Final s {}".format(ss))
+            else:
+                logging.info("Epoch {}, s {}".format(epoch, ss))

scripts/model/model_concatenation.py

@@ -0,0 +1,92 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from gcn_lib.sparse.torch_nn import MLP
+
+from model.model import DeeperGCN
+
+import numpy as np
+import logging
+
+
+class PLANet(torch.nn.Module):
+    def __init__(self, args,saliency=False):
+        super(PLANet, self).__init__() 
+
+        # Args
+        self.args = args
+        # Molecule and protein networks
+        self.molecule_gcn = DeeperGCN(args, saliency=saliency)
+        self.target_gcn = DeeperGCN(args, is_prot=True)
+
+        # Individual modules' final embbeding size
+        output_molecule = args.hidden_channels
+        output_protein = args.hidden_channels_prot
+        # Concatenated embbeding size
+        Final_output = output_molecule + output_protein
+        # Overall model's final embbeding size
+        hidden_channels = args.hidden_channels
+
+        # Multiplier
+        if args.multi_concat:
+            self.multiplier_prot = torch.nn.Parameter(torch.zeros(hidden_channels))
+            self.multiplier_ligand = torch.nn.Parameter(torch.ones(hidden_channels))
+        elif self.args.MLP:
+            # MLP
+            hidden_channel = 64
+            channels_concat = [256, hidden_channel, hidden_channel, 128]
+            self.concatenation_gcn = MLP(channels_concat, norm=args.norm, last_lin=True)
+            # breakpoint()
+            indices = np.diag_indices(hidden_channel)
+            tensor_linear_layer = torch.zeros(hidden_channel, Final_output)
+            tensor_linear_layer[indices[0], indices[1]] = 1
+            self.concatenation_gcn[0].weight = torch.nn.Parameter(tensor_linear_layer)
+            self.concatenation_gcn[0].bias = torch.nn.Parameter(
+                torch.zeros(hidden_channel)
+            )
+        else:
+            # Concatenation Layer
+            self.concatenation_gcn = nn.Linear(Final_output, hidden_channels)
+            indices = np.diag_indices(output_molecule)
+            tensor_linear_layer = torch.zeros(hidden_channels, Final_output)
+            tensor_linear_layer[indices[0], indices[1]] = 1
+            self.concatenation_gcn.weight = torch.nn.Parameter(tensor_linear_layer)
+            self.concatenation_gcn.bias = torch.nn.Parameter(
+                torch.zeros(hidden_channels)
+            )
+
+        # Classification Layer
+        num_classes = args.nclasses
+        self.classification = nn.Linear(hidden_channels, num_classes)
+
+    def forward(self, molecule, target):
+
+        molecule_features = self.molecule_gcn(molecule)
+        target_features = self.target_gcn(target)
+        # Multiplier
+        if self.args.multi_concat:
+            All_features = (
+                target_features * self.multiplier_prot
+                + molecule_features * self.multiplier_ligand
+            )
+        else:
+            # Concatenation of LM and PM modules
+            All_features = torch.cat((molecule_features, target_features), dim=1)
+            All_features = self.concatenation_gcn(All_features)
+        # Classification
+        classification = self.classification(All_features)
+
+        return classification
+
+    def print_params(self, epoch=None, final=False):
+
+        logging.info("======= Molecule GCN ========")
+        self.molecule_gcn.print_params(epoch)
+        logging.info("======= Protein GCN ========")
+        self.target_gcn.print_params(epoch)
+        if self.args.multi_concat:
+            sum_prot_multi = sum(self.multiplier_prot)
+            sum_lig_multi = sum(self.multiplier_ligand)
+            logging.info("Sumed prot multi: {}".format(sum_prot_multi))
+            logging.info("Sumed lig multi: {}".format(sum_lig_multi))

scripts/model/model_encoder.py

@@ -0,0 +1,54 @@
+import torch
+from data.features import get_atom_feature_dims, get_bond_feature_dims 
+
+full_atom_feature_dims = get_atom_feature_dims()
+full_bond_feature_dims = get_bond_feature_dims()
+
+class AtomEncoder(torch.nn.Module):
+
+    def __init__(self, emb_dim):
+        super(AtomEncoder, self).__init__()
+        
+        self.atom_embedding_list = torch.nn.ModuleList()
+
+        for i, dim in enumerate(full_atom_feature_dims):
+            emb = torch.nn.Embedding(dim, emb_dim)
+            torch.nn.init.xavier_uniform_(emb.weight.data)
+            self.atom_embedding_list.append(emb)
+
+    def forward(self, x):
+        x_embedding = 0
+        for i in range(x.shape[1]):
+            x_embedding += self.atom_embedding_list[i](x[:,i])
+
+        return x_embedding
+
+
+class BondEncoder(torch.nn.Module):
+    
+    def __init__(self, emb_dim):
+        super(BondEncoder, self).__init__()
+        
+        self.bond_embedding_list = torch.nn.ModuleList()
+
+        for i, dim in enumerate(full_bond_feature_dims):
+            emb = torch.nn.Embedding(dim, emb_dim)
+            torch.nn.init.xavier_uniform_(emb.weight.data)
+            self.bond_embedding_list.append(emb)
+
+    def forward(self, edge_attr):
+        bond_embedding = 0
+        for i in range(edge_attr.shape[1]):
+            bond_embedding += self.bond_embedding_list[i](edge_attr[:,i])
+
+        return bond_embedding   
+
+
+if __name__ == '__main__':
+    from loader import GraphClassificationPygDataset
+    dataset = GraphClassificationPygDataset(name = 'tox21')
+    atom_enc = AtomEncoder(100)
+    bond_enc = BondEncoder(100)
+
+    print(atom_enc(dataset[0].x))
+    print(bond_enc(dataset[0].edge_attr))

scripts/pla_net_inference.py

@@ -0,0 +1,82 @@
+import torch
+import numpy as np
+import pandas as pd
+import time
+from torch_geometric.data import DataLoader
+from model.model_concatenation import PLANet
+from utils.args import ArgsInit
+from utils.model import get_dataset_inference, test_gcn
+
+
+def main(args):
+
+    if args.use_gpu:
+        device = torch.device("cuda:" + str(args.device)) if torch.cuda.is_available() else torch.device("cpu")
+    else:
+        device = torch.device('cpu')
+    
+    #Numpy and torch seeds
+    torch.manual_seed(args.seed)
+    np.random.seed(args.seed)
+    if device.type == 'cuda':
+        torch.cuda.manual_seed(args.seed)
+    print('%s' % args)
+    
+    
+    data_inference = pd.read_csv(
+        args.input_file_smiles, 
+        names=["Smiles"],
+        header=0
+    )
+ 
+    print("Data Inference: ", data_inference)
+
+    data_target = pd.read_csv(
+        args.target_list, names=["Fasta", "Target", "Label"]
+    )
+    data_target = data_target[data_target.Target == args.target]
+
+    print("Data Target: ", data_target)
+
+    test = get_dataset_inference(
+        data_inference,
+        use_prot=args.use_prot,
+        target=data_target,
+        args=args,
+        advs=False,
+        saliency=False,
+    )
+    
+    test_loader = DataLoader(test, batch_size=args.batch_size, shuffle=False,
+                            num_workers=args.num_workers)
+
+    model = PLANet(args).to(device)
+
+
+    print('Model inference in: {}'.format(args.inference_path))
+    start_time = time.time()
+
+    #Load pre-trained molecule model
+
+    print('Evaluating...')
+    test_gcn(model, device, test_loader, args)
+
+
+    end_time = time.time()
+    total_time = end_time - start_time
+    print('Total time: {}'.format(time.strftime('%H:%M:%S', time.gmtime(total_time))))
+
+
+if __name__ == "__main__":
+    args = ArgsInit().args
+    # Default args for inference
+    
+    args.nclasses = 2
+    args.batch_size = 10
+    args.use_prot = True
+    args.freeze_molecule = True
+    args.conv_encode_edge = True
+    args.learn_t = True
+    args.binary = True
+    
+    main(args)

setup.py

@@ -0,0 +1,14 @@
+# setup.py
+from setuptools import setup, find_packages
+
+with open('requirements.txt') as f:
+    requirements = f.read().splitlines()
+
+setup(
+    name='pla_net',
+    version='0.0.0',
+    packages=find_packages(),
+    install_requires=[requirements],
+    classifiers=[],
+    python_requires='>=3.8',
+)

utils/__init__.py

@@ -0,0 +1,4 @@
+import sys
+import os
+ROOT_DIR = os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+sys.path.append(ROOT_DIR)