{"metadata":{"kernelspec":{"name":"python3","display_name":"Python 3","language":"python"},"language_info":{"name":"python","version":"3.12.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceType":"competition","sourceId":116062,"databundleVersionId":14875579,"isSourceIdPinned":false},{"sourceType":"datasetVersion","sourceId":15920072,"datasetId":9294895,"databundleVersionId":16876601}],"dockerImageVersionId":31234,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Large-Scale Protein Function Prediction Using Pre-trained Language Model Embeddings and Hierarchical Classification\n\nAuthor: Gordon Ma\n\n**Abstract**\n*Automated protein function annotation remains a fundamental challenge in bioinformatics, essential for decoding molecular biology and accelerating drug discovery. This notebook introduces a computational pipeline for the CAFA 6 challenge, a prospective benchmark that validates computational predictions against emerging experimental data. This pipeline utilizes pre-trained protein language models (pLM) to convert protein sequences into fixed-length embeddings. These embeddings are used as features in a hierarchical neural network to classify proteins into their corresponding functions. We detail our methodology, from data preprocessing, feature extraction, model training and the generation of a submission file.*","metadata":{}},{"cell_type":"markdown","source":"# **1. Introduction**\n\nProteins are responsible for many activities in biological systems and play a central role in the structure and function of cells [1]. Consequently, characterizing these functions is crucial for understanding life at the molecular level and leads to curing diseases. In recent years, advances in sequencing technology have made millions of protein sequences known, but their precise biological roles remain uncharacterized [2].\nThe reason is that experimental validation can require significant resources and time—often years—for even a single protein. Therefore, computational approaches for function prediction have become an indispensable tool. The Critical Assessment of Functional Annotation (CAFA) is a prospective competition that validates computational predictions against emerging experimental data [3]. Participants have three months to build their best prediction model, and the performance will be evaluated on the test set collected during the curation phase, which is after the competition deadline. \n\n\nThe central challenge of this competiition involves mapping protein sequences three distinct categories defined by the Gene Ontology (GO): 1) Molecular Function (MF): The specific biochemical activity (e.g., \"binding to ATP\"); 2) Biological Process (BP): The larger goal the protein contributes to (e.g., \"cell division\"); 3) Cellular Component (CC): Where the protein lives (e.g., \"mitochondrion\"). Additionally, the Gene Ontology (GO) terms are organized in a hierarchical structure, represented by a Directed Acyclic Graph (DAG). A single protein may have dozens of labels across these three trees, making this a large-scale, multi-label, hierarchical classification problem with over 40,000 possible categories [4]. Moreover, many GO terms are extremely rare, making this a highly unbalanced classification problem.\n\n\nTraditional methods primarily used homology—the idea that if two proteins share a common ancestor, they likely share a common function. These include sequence similarity methods (e.g. BLAST), phylogenetic profiling and Protein-Protein Interaction (PPI) Networks. However, these methods can be limited for proteins with few known homologs (the \"twilight zone\"). Recently, protein language models (pLMs), such as ProtT5 [5], have significantly advanced the field. These pLMs are based on the transformer architectures [6] and trained on vast unlabeled datasets in a self-supervised manner. These models learned the context-aware representations of protein sequences, which have been shown to capture latent biophysical and evolutionary signatures of proteins. These representations are directly useful for various downstream tasks, such as function prediction. \n\n\n\n![image.png](attachment:3d9e20a8-91a3-4203-b363-194298b60950.png)\n\nFigure 1: Illustration of the protein function prediction problem. The blue nodes in the ontology depict the anticipated function of the given protein. Note that a protein can belong to multiple paths simultaneously, and leaf annotation nodes uniquely define the entire consistent subgraph.\n","metadata":{},"attachments":{"3d9e20a8-91a3-4203-b363-194298b60950.png":{"image/png":"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"}}},{"cell_type":"code","source":"# ==============================================================================\n# INITIAL SETUP AND LIBRARY IMPORTS\n# ==============================================================================\n\n# --- Install Required Packages ---\n# obonet is for parsing the Gene Ontology .obo file.\n# Biopython is for parsing FASTA sequence files.\n# transformers and sentencepiece are for the protein language model.\n# cafaeval is the evaluation script for this competition. \n!pip install -q obonet biopython transformers sentencepiece cafaeval\n\n# --- Core Libraries ---\nimport os\nimport gc\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nfrom tqdm.notebook import tqdm\nimport time\nimport random\n\nfrom collections import defaultdict, deque, OrderedDict\n\n# --- Bioinformatics & Data Handling ---\nfrom Bio import SeqIO\nimport obonet\nimport networkx as nx\n\n# --- Machine Learning ---\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.preprocessing import MultiLabelBinarizer\nfrom sklearn.metrics import f1_score\nimport torch\nimport torchvision\nfrom torch.utils.data import DataLoader, Dataset, Subset\n\n# --- CAFA6 competition evaluation scipt --- \nimport cafaeval\nfrom cafaeval.evaluation import cafa_eval, write_results\n\n# --- Helper function ---\nimport cafa6_ultility_script as utils\n\n# Set seed\nseed = 42\ntorch.manual_seed(seed)\nnp.random.seed(seed)\n\n# Device configuration \ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nprint(\"Using device:\", device)\n\n# Define base path for data.\nBASE_PATH = \"/kaggle/input/competitions/cafa-6-protein-function-prediction\"\n","metadata":{"execution":{"iopub.execute_input":"2026-04-24T01:46:42.699364Z","iopub.status.busy":"2026-04-24T01:46:42.699123Z","iopub.status.idle":"2026-04-24T01:47:25.211211Z","shell.execute_reply":"2026-04-24T01:47:25.210055Z","shell.execute_reply.started":"2026-04-24T01:46:42.699340Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# **2. Problem formulation**\n\nLet $\\mathcal{P} = \\{p_1, p_2, \\dots, p_N\\}$ be the set of $N$ protein sequences in the training set, and $\\mathcal{G} = \\{g_1, g_2, \\dots, g_M\\}$ be the set of all possible Gene Ontology (GO) terms. The training data is a set of pairs $(p_i, G_i)$, where $G_i \\subseteq \\mathcal{G}$ is the set of known GO terms for protein $p_i$. The functional annotation $G_i$ corresponding to $p_i$ is required to be a consistent\nsubgraph of O. This means that if a term (vertex) $v \\in G_i$ is associated with $p_i$,\nthen all ancestors of v must also be in $G_i$ up to the root(s) of the ontology. \n\nThe task is to learn a function $f: p \\rightarrow \\mathbb{R}^M$ that, for any given protein sequence $p$, outputs a vector of prediction scores $\\mathbf{\\hat{y}} = (\\hat{y}_1, \\hat{y}_2, \\dots, \\hat{y}_M)$, where $\\hat{y}_j \\in [0, 1]$ is the predicted probability that protein $p$ is associated with GO term $g_j$. Thus, a decision threshold $\\tau$ must be applied to determine the set of predicted terms $P(\\tau)$. Similarly, A set of experimentally determined terms will be denoted as $T$. To determine the quality of prediction, a similarity function must be calculated between $P(\\tau)$ and $T$ for each protein in an evaluation set.\n\n\nEach term f in the ontology was weighted by its information content. The information content of the term f was\n$$ic(f) = \\log_2 \\frac{1}{\\Pr(f|\\mathcal{P}(f))}, $$\nwhere $\\Pr(f|\\mathcal{P}(f))$ is the probability that the term f in the ontology is associated with a protein given that all of its parents are associated. (Probabilities were determined based on the union of SwissProt, UniProt-GOA and GO Consortium databases). This specific form of $ic$ measures how much \"surprise\" or specific information a node adds relative to its ancestors. If a node is almost certain to occur given its parent, it provides very little new information. Weighted precisions and recalls are calculated\nas \n$$ wpr(\\tau) = \\frac{1}{m(\\tau)} \\sum_{i=1}^{m(\\tau)} \\frac{\\sum_{f} ic(f) \\cdot \\mathbb{1} (f \\in P_i(\\tau) \\wedge T_i)}{\\sum_{f} ic(f) \\cdot \\mathbb{1} (f \\in P_i(\\tau))}, \\quad \\text{and} $$\n\n$$ wrc(\\tau) = \\frac{1}{n_e} \\sum_{i=1}^{n_e} \\frac{\\sum_{f} ic(f) \\cdot \\mathbb{1} (f \\in P_i(\\tau) \\wedge T_i)}{\\sum_{f} ic(f) \\cdot \\mathbb{1} (f \\in T_i)}, $$\n\n\nwhere $P_i(\\tau)$ is the set of predicted terms for protein $i$ with score no less than threshold $\\tau$ and $T_i$ is the set of true terms for protein $i$, $m(\\tau)$ is the number of sequences with at least one predicted score greater than or equal to $\\tau$, and $n_e$ is the number of proteins used in a particular mode ofevaluation. The reason this is used instead of the average precision and recall is that, in an ontology, correctly predicting a very specific child term is much harder and more informative than predicting a broad parent term. By multiplying the indicator function by $ic(f)$, these metrics reward the model more for correctly predicting specific, \"high-information\" nodes.\n\n\nWhen all possible thresholds are considered, a prediction model is characterized by a weighted precision-recall curve $(wpr(\\tau), wrc(\\tau) )_{\\tau}$. Generally, there is a tradeoff between recall and precision by adjusting $\\tau$. To provide a single-score evaluation of computational models, we used the maximum F-measure over all thresholds. Specifically,\n$$ F_{\\max} = \\max_{\\tau} \\left\\{ \\frac{2 \\cdot wpr(\\tau) \\cdot wrc(\\tau)}{wpr(\\tau) + wrc(\\tau)} \\right\\}. $$\nNote this is a harmonic mean between $wpr(\\tau)$ and $wrc(\\tau)$, which places equal emphasis on both quantities. This measures the best model performance, independent of the threshold value $\\tau$.  \n\nThis is the future data competition - the test set will be collected in the four-month curation phase after the competition deadline.\n","metadata":{}},{"cell_type":"markdown","source":"# **3. Data Loading, exploration and modification**\n\nThe competition provides data in several standard bioinformatics formats:\n- **FASTA (`.fasta`):** Used for protein sequences. Each entry contains a header (with the protein ID) and the amino acid sequence.\n- **Tab-Separated Values (`.tsv`):** Used for tabular data like training terms and taxonomy.\n- **Open Biomedical Ontologies (`.obo`):** A standard format for representing ontologies like the Gene Ontology.\n\n\nThe test superset contains ~$220,000$ proteins. As this is the future data competition, the evaluation test set will be a subset of this set.  After the submission deadline, there will be a four-month curation phase. During this phase, if any proteins from the test superset have had one or more of their functions published by researchers, those proteins will be included in the evaluation set.\n\n\nThe training set consists of $82,404$ proteins. This training set is also a subset of the test superset. This train set also contains most of the labelled proteins from the bioinformatics database, such as UniProt, so no additional data collection was required. To evaluate the performance of the model, I randomly subset $10,000$ samples from the training set to use as a validation set. No temporal splitting was performed as this would require much data collection and cleaning effort. \n\n\nI use the `obonet` library to parse the `go-basic.obo` file into a graph object. The graph encodes the hierarchical relationship within the Gene Ontologies. I keep only the edges with descriptions `is_a` and `part_of`, as these are the only ones describing \"parent-child\" relationship. \n\n**Table 1: Key Attributes of the Gene Ontology Graph**\n| Attribute | Description | Example |\n|---|---|---|\n| **Node ID** | The unique GO term identifier. | `GO:0003674` |\n| **Node Name** | The human-readable name of the term. | `molecular_function` |\n| **Namespace**| The sub-ontology (BP, MF, or CC). | `molecular_function` |\n| **Edges** | The relationships between terms (e.g., `is_a`).| `GO:0003824` is_a `GO:0003674`|\n\n\nSince `train_terms.tsv` only contains the leaf node annotations, I perform data propagation according to the Gene Ontology Graph - if a GO term is associated with a protein, then all its parents in the Graph must also be annotated with the same protein. After making these modifications, I save the updated data to a new file `/kaggle/input/datasets/guojun1/t5-embedding/train_terms_propagated.tsv`. To convert to a format suitable for machine learning, I construct a target matrix $T$, where $T_{ij} = 1$ if protein $i$ is annotated with GO term $j$ and $T_{ij} = 0$ otherwise. Since many GO terms are extremely rare, I only select the top $10,000$ most frequent terms. \n","metadata":{}},{"cell_type":"code","source":"# ==============================================================================\n# DATA LOADING AND INITIAL PARSING\n# ==============================================================================\n\n# --- Load Gene Ontology Graph (Keep only edges indicating relationships of \"is_a\" and \"part_a\"---\ndef parse_obo_file(obo_path):\n    \"\"\"\n    Parse the OBO file to create a directed graph of GO terms, keeping only the relationship \"part_of\" and \"is_a\"\n    \"\"\"\n    graph = obonet.read_obo(obo_path)\n    # Filter the graph to keep only 'part_of' and 'is_a' relationships\n    filtered_graph = nx.MultiDiGraph()\n    # Add all nodes from the original graph\n    filtered_graph.add_nodes_from(graph.nodes(data=True))\n    # Add only edges with 'part_of' or 'is_a' relationships\n    for parent, child, key, data in graph.edges(keys=True, data=True):\n        if key in {'part_of', 'is_a'}:\n            filtered_graph.add_edge(parent, child, key=key, **data)\n    return filtered_graph\n\ngo_graph = parse_obo_file(os.path.join(BASE_PATH,'Train/go-basic.obo'))\nprint(f\"Gene Ontology graph loaded with {len(go_graph)} nodes and {len(go_graph.edges)} edges.\")\n\n\ndef construct_target_matrix(train_terms_path, N_LABELS=10000):\n    # Process the raw training data into a format suitable for machine learning: a feature matrix (X) and a target matrix (Y).\n    train_terms_df = pd.read_csv(train_terms_path, sep='\\\\t')\n    \n    # --- Limit the number of labels for computational efficiency ---\n    # The full GO ontology has ~40,000 terms. Many are extremely rare.\n\n    # --- Identify the top N most frequent GO terms ---\n    top_n_labels = train_terms_df['term'].value_counts().nlargest(N_LABELS).index.tolist()\n    print(f\"Identified the top {N_LABELS} most frequent GO terms.\")\n\n    # --- Filter the training data to only include these top labels ---\n    train_terms_filtered_df = train_terms_df[train_terms_df['term'].isin(top_n_labels)]\n    print(f\"Filtered training terms. New shape: {train_terms_filtered_df.shape}\")\n\n    # --- Create a list of unique proteins in our filtered dataset ---\n    unique_proteins = train_terms_filtered_df['EntryID'].unique()\n    print(f\"Number of unique proteins with top {N_LABELS} labels: {len(unique_proteins)}\")\n\n    # --- Create a mapping from protein ID to a list of its GO terms ---\n    protein_to_go_map = train_terms_filtered_df.groupby('EntryID')['term'].apply(list).to_dict()\n\n    # --- Use MultiLabelBinarizer to create the target matrix Y ---\n    # This converts the list of GO terms for each protein into a binary vector.\n    mlb = MultiLabelBinarizer(classes=top_n_labels)\n    Y_train = mlb.fit_transform([protein_to_go_map.get(prot, []) for prot in unique_proteins])\n    Y_train = pd.DataFrame(Y_train, index=unique_proteins, columns = mlb.classes_)\n\n    print(f\"Target matrix Y_train created with shape: {Y_train.shape}\")\n    # Y_train.shape will be (number of unique proteins, N_LABELS)\n    return Y_train\n\nY_train = construct_target_matrix(\"/kaggle/input/datasets/guojun1/t5-embedding/train_terms_propagated.tsv\")\nprint(f\"Constructed target matrix Y_train with shape: {Y_train.shape}\")\n\n# Split into train and validation sets\nrandom.seed(seed)\nval_index = random.sample(range(Y_train.shape[0]), k=10000)\ntrain_index = list(set(range(Y_train.shape[0])) - set(val_index))\n\nval_protein_ids = [Y_train.index[i] for i in val_index]\ntrain_protein_ids = [Y_train.index[i] for i in train_index]\n\n","metadata":{"execution":{"iopub.execute_input":"2026-04-24T01:47:25.213942Z","iopub.status.busy":"2026-04-24T01:47:25.212983Z","iopub.status.idle":"2026-04-24T01:47:36.673568Z","shell.execute_reply":"2026-04-24T01:47:36.672738Z","shell.execute_reply.started":"2026-04-24T01:47:25.213918Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# **4. Feature Engineering: Protein Language Model Embeddings**\nThe core of our feature engineering strategy is the use of pre-trained protein language models (pLMs). These models have been trained on vast databases of protein sequences (e.g., UniRef). They have demonstrated the ability to capture the intricate \"language\" of protein biology, including evolutionary and structural information[5, 7, 8]. I use the **ProtT5-XL-U50** model [5], which is based on the T5 (Text-to-Text Transfer Transformer) architecture.\n\nA protein sequence $p$ is a string of amino acids from an alphabet $\\mathcal{A}$ of size 20. A protein language model transforms this sequence into a fixed-length numerical vector, or embedding, extracted from the last layer of the model. The pLM, denoted $\\Phi$, maps a sequence of length $L$ to a sequence of hidden states $\\mathbf{H} \\in \\mathbb{R}^{L \\times d_{embed}}$.\n\n$$\n\\Phi(p) = \\mathbf{H} = (\\mathbf{h}_1, \\mathbf{h}_2, \\dots, \\mathbf{h}_L)\n$$\n\nTo obtain a single vector representation for the entire protein, we perform a mean-pooling operation over the length dimension.\n\n$$\n\\mathbf{e}_p = \\frac{1}{L} \\sum_{i=1}^{L} \\mathbf{h}_i\n$$\n\nThis embedding $\\mathbf{e}_p \\in \\mathbb{R}^{d_{embed}}$ serves as the input features for our downstream classification model. For ProtT5, $d_{embed}=1024$.\n\n\nDue to the extensive run-time required for the Protein language model, I first generate embeddings for all proteins in `train_sequences.fasta` and `testsuperset.fasta` in a separate notebook. We save these embeddings as a Kaggle dataset and load them directly here. \n\n","metadata":{"execution":{"iopub.execute_input":"2026-03-21T18:30:29.152485Z","iopub.status.busy":"2026-03-21T18:30:29.151269Z","iopub.status.idle":"2026-03-21T18:30:29.156961Z","shell.execute_reply":"2026-03-21T18:30:29.155924Z","shell.execute_reply.started":"2026-03-21T18:30:29.152448Z"}}},{"cell_type":"code","source":"# Load the protT5 embedding from the Kaggle dataset. \ntrain_embedding = pd.read_pickle(\"/kaggle/input/datasets/guojun1/t5-embedding/train_protT5_embeddings.pkl\")\n#test_embedding = pd.read_pickle(\"/kaggle/input/datasets/guojun1/t5-embedding/test_protT5_embeddings.pkl\")\n\n#Reorder the target matrix so that the index matches the train embedding matrix. \ntrain_embedding = train_embedding.reindex(Y_train.index)\nall(train_embedding.index == Y_train.index)\n","metadata":{"execution":{"iopub.execute_input":"2026-04-24T01:47:40.449422Z","iopub.status.busy":"2026-04-24T01:47:40.449209Z","iopub.status.idle":"2026-04-24T01:47:49.780067Z","shell.execute_reply":"2026-04-24T01:47:49.779567Z","shell.execute_reply.started":"2026-04-24T01:47:40.449403Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# **5. Hierarchical classification neural network** \n\n**Model architecture**\n\nIn this section, I implement the hierarchical multi-label classification neural network. The neural network comprises $l$ local predictions and one global prediction (Figure 2). Formally, $x$ is the learned embeddings from the protein language model. The first level activation is given by $$A_G^1 = \\phi (W_G^1 x + b_G^1),$$ where $W_G^1$ is the weight matrix and $b_G^1$ is the bias for the first layer, which are parameters for learning the global information. $\\phi$ is the non-linear activiation(e.g. Relu). The subsequent global activations are given by $$A_G^h = \\phi (W_G^{h} (A_G^{h-1} \\oplus x) + b_G^h),$$ where $W_G^{h}$ is the $h$th hiearchical level, $b_G^h$ is the corresponding bias, and $\\oplus$ denotes the vector concatenation. The prediction based on the global information is produced at the last layer $H$, $$P_G = \\sigma (W_G^H A_G^H + b_G^H ),$$ where $\\sigma$ is the sigmoid function to convert to probability prediction. Similarly, the local level prediction for level $h$ is the following, $$P_L^h = \\sigma(W_L^h A_L^h + b_L^h),$$\nwhere $A_L^h$ is the local hidden layer and $b_L^h$ is the local bias. The final prediction is the combination of global and local prediction, $$P_F = (1 - \\beta) \\oplus_{i \\leq H} P_L^i + \\beta P_G,$$ \nwhere $\\beta \\in [0,1]$ is the weights. We set $\\beta = 0.5$ as the default value to give equal importance to both local and global information from the class hierarchy. The model weights $W_G, W_L, b_G, b_L$ are learned during the training. \n\n\n\n![image.png](attachment:image.png)\n\n**Figure 2: Architecture of hierarchical multi-label neural network. Each layer corresponds to each hierarchical level in the dataset. At each layer of the neural network, a local logits prediction $P_L$ is produced. Each layer also produces the embedding, which is concatenated with the feature $x$ and feed forward to the next layer. The global logits prediction $P_G$ is produced at the last layer, which use informataion accumated from all layers. Finally, the final prediction is a convex combination of local and global predictions.** \n\n**Loss function**\n\nFor a protein sequence input, the model produces a probability of association with each Gene Ontology term. The binary cross-entropy (BCE) loss function measures the performance of a model by comparing predicted probabilities to true labels. However, many Gene Ontology terms are extremely rare, and BCE is highly sensitive to an imbalanced dataset. Instead, I implement the focal loss function [11] for training. The focal loss function for one sample is defined as \n$$\nL(p_t) = − \\alpha_t (1 − p_t)^{\\gamma} \\log(p_t), \n$$ \n$$ \np_t = \n\\begin{cases}\np & \\text{if } y = 1 \\\\\n1-p & \\text{otherwise}. \n\\end{cases}\n$$\nIn the above, $y \\in \\{±1\\}$ specifies the ground-truth class and $p \\in [0, 1]$ is the model’s estimated probability for the class with label $y = 1$, $\\alpha_t$ and $\\gamma$ are scaling parameters. Note that $\\log(p_t)$ is the standard BCE loss function. The focal loss is designed to downweight the BCE for those well-classified samples (Large $p_t$). This modification enables the model to focus on the hard subset of examples during training. The parameters $\\alpha = 0.25, \\beta = 2$ were used to scale the loss function. \n\n\nA crucial rule of the CAFA challenge is that predictions must be consistent with the GO hierarchy. If a protein is predicted to have a specific function (a child term), it must also be predicted to have all of its parent functions up to the root. To encourage the model to produce a prediction respecting the hierarchy, an additional term was added to the loss function, which penalizes if the prediction of a child term is greater than its parents. \n\n$$\nL_{hier.loss} = \\sum Relu (p_{\\text{child}} - p_{\\text{parent}}), \n$$\nwhere $Relu(x) = x$ if $x > 0$ and $Relu(x) = 0$ if $x \\leq 0$. The summation is over all parent-child pairs in the Gene Ontology graph. So the total loss is given as \n$$\nL_{total} = L(p_t) + L_{\\text{hier.loss}} \n$$\n\n\nAdam optimizer [10] was used for training with parameters: `learning rate` = $0.001$, `weight decay` = $1 * 10^{-5}$ and `beta` = $(0.9,0.999)$. The model was trained on the training samples for $100$ epoches and a batch size of $512$. \n\n\n","metadata":{},"attachments":{"image.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"## **5.1 Model Initialization**","metadata":{}},{"cell_type":"code","source":"import torch.nn as nn\nclass HMCN(nn.Module):\n    def __init__(self,\n                in_dims: int,\n                hidden_size: int,\n                classes, #: OrderedDict[str, Tuple[int, int]],  # ('class_name', (class_num, middle_size))\n                graph,\n                act_fn: nn.Module = nn.ReLU,\n                bias: bool = False,\n                dropout: float = .5,\n                beta: float = .5):\n        super().__init__()\n\n        self.classes_names = list(classes.keys())\n        self.classes_nums = [i[0] for i in classes.values()]\n\n        self.global_layers = nn.ModuleList()\n        self.local_layers = nn.ModuleList()\n\n        for i, (name, (cls_num, mid_size)) in enumerate(classes.items()):\n            self.global_layers.append(\n                nn.Sequential(OrderedDict([\n                    (f'{name}_global_fc', nn.Linear(in_dims + (hidden_size if i else 0),\n                                                    hidden_size, bias=bias)),\n                    (f'{name}_global_act', act_fn()),\n                    (f'{name}_global_ln', nn.LayerNorm(hidden_size)),\n                    (f'{name}_global_dropout', nn.Dropout(dropout))\n                    ]))\n                )\n            self.local_layers.append(\n                nn.Sequential(OrderedDict([\n                    (f'{name}_local_fc', nn.Linear(hidden_size, mid_size, bias=bias)),\n                    (f'{name}_local_act', act_fn()),\n                    (f'{name}_local_ln', nn.LayerNorm(mid_size)),\n                    (f'{name}_local_fc2', nn.Linear(mid_size, cls_num, bias=bias))\n                    ]))\n                )\n\n        self.proj_layer = nn.Linear(in_dims + hidden_size,\n                                    sum([i[0] for i in classes.values()]),\n                                    bias=bias)\n        self.beta = beta\n\n        # Pre-compute hierarchical violation indices\n        if graph is not None:\n            # Reverse the graph to have edges from parent to child\n            graph = graph.reverse()\n\n            go_term_list = []\n            for level in sorted(go_terms_at_level.keys()):\n                go_term_list.extend(go_terms_at_level[level])\n            \n            go_to_idx = {go: idx for idx, go in enumerate(go_term_list)}\n            \n            parent_indices = []\n            child_indices = []\n            \n            for parent, child in graph.edges():\n                if parent in go_to_idx and child in go_to_idx:\n                    parent_indices.append(go_to_idx[parent])\n                    child_indices.append(go_to_idx[child])\n            \n            # Register as buffers (non-trainable parameters)\n            self.register_buffer('parent_edge_idx', torch.tensor(parent_indices, dtype=torch.long))\n            self.register_buffer('child_edge_idx', torch.tensor(child_indices, dtype=torch.long))\n        else:\n            self.parent_edge_idx = None\n            self.child_edge_idx = None\n\n\n    def make_dict_logits(self, logits):\n        return dict(zip(self.classes_names, torch.split(logits, self.classes_nums, dim=-1)))\n\n    def forward(self,\n                features: torch.Tensor,\n                return_local_logits: bool = True,\n                return_global_logits: bool = True,\n                return_fused_logits: bool = True,\n                return_logits_dict: bool = True):\n        local_logits = []\n        last_global = torch.Tensor().to(device=features.device)\n\n        for global_layer, local_layer in zip(self.global_layers, self.local_layers):\n            last_global = global_layer(torch.cat([features, last_global], dim=-1))\n            local_logits.append(local_layer(last_global))\n\n        local_logits = torch.cat(local_logits, dim=-1)\n        global_logits = self.proj_layer(torch.cat([features, last_global], dim=-1))\n\n        logits = {}\n\n        if(return_local_logits):\n            logits['local_logits'] = self.make_dict_logits(local_logits) if return_logits_dict else local_logits\n\n        if(return_global_logits):\n            logits['global_logits'] = self.make_dict_logits(global_logits) if return_logits_dict else global_logits\n\n        if(return_fused_logits):\n            fused_logits = local_logits * (1 - self.beta) + global_logits * self.beta\n            logits['fused_logits'] = self.make_dict_logits(fused_logits) if return_logits_dict else fused_logits\n\n        return logits\n\n    def loss(self,\n            inputs,\n            targets,\n            weights = None,\n            reduction = 'sum',\n            alpha: float = 0.25,\n            gamma: float = 2, \n            hier_viol: float = 0.1):\n        # criterion = torch.nn.BCEWithLogitsLoss(reduction=reduction)\n        local_loss = {c: torchvision.ops.sigmoid_focal_loss(inputs['local_logits'][c],targets[c],\n                        alpha = alpha, gamma = gamma, reduction = reduction) for c in self.classes_names}\n        global_loss = {c: torchvision.ops.sigmoid_focal_loss(inputs['global_logits'][c],targets[c],\n                        alpha = alpha, gamma = gamma, reduction = reduction) for c in self.classes_names}\n        losses = {c: (local_loss[c] + global_loss[c]) * \\\n                                    (weights[c] if weights is not None else 1) for c in self.classes_names}\n        losses['total_loss'] = torch.stack(list(losses.values()))\n        losses['total_loss'] = losses['total_loss'].mean() if reduction == 'mean' else losses['total_loss'].sum()\n        \n        if hier_viol > 0:\n            # Get predictions for all GO terms across all levels\n            preds = {c: torch.sigmoid(inputs['fused_logits'][c]) for c in self.classes_names}\n            \n            # Concatenate all predictions\n            pred_matrix = torch.cat([preds[c] for c in sorted(preds.keys())], dim=1)\n            \n            # Vectorized violation computation (using pre-computed indices)\n            parent_preds = pred_matrix[:, self.parent_edge_idx]\n            child_preds = pred_matrix[:, self.child_edge_idx]\n\n            violations = torch.relu(child_preds - parent_preds)\n            hier_viol_loss = (violations.sum()) * hier_viol\n\n            losses['hierarchical_violation'] = hier_viol_loss\n            losses['total_loss'] += hier_viol_loss\n\n        return losses","metadata":{"execution":{"iopub.execute_input":"2026-04-24T02:38:12.097425Z","iopub.status.busy":"2026-04-24T02:38:12.097157Z","iopub.status.idle":"2026-04-24T02:38:12.113995Z","shell.execute_reply":"2026-04-24T02:38:12.113379Z","shell.execute_reply.started":"2026-04-24T02:38:12.097404Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## **5.2 Data preprocessing** \nTo prepare the data for training, I need to first group the GO terms based on their hiearchical levels.   ","metadata":{}},{"cell_type":"code","source":"# Mapping GO terms to the level in the Gene Ontology graph\ndef count_go_terms_by_level(graph, GO_terms):\n    \"\"\"\n    Implement Breadth-First Search (BFS) to count GO terms at each hierarchical level. \n    graph: A directed graph where nodes are GO terms and edges represent \"is_a\" or \"part_a\" relationships.\n    GO_terms: A list of GO terms (strings) to be included in the count (e.g., those present in Y_train.columns).\n    \"\"\"\n    # Reverse the graph so edges point from parent to child\n    reversed_graph = graph.reverse()\n\n    # Filter graph to only include GO_terms\n    filtered_terms = set(GO_terms)\n\n    # Find root nodes (nodes with no predecessors in the REVERSED graph, i.e., no parents in original)\n    root_nodes = [node for node in filtered_terms if node in reversed_graph and reversed_graph.in_degree(node) == 0]\n\n    print(f\"Found {len(root_nodes)} root nodes\")\n\n    # BFS to assign levels\n    level_counts = defaultdict(int)\n    term_levels = {}\n\n    # Initialize with root nodes at level 0\n    queue = deque()\n    for root in root_nodes:\n        queue.append((root, 0))\n        term_levels[root] = 0\n\n    # BFS traversal\n    while queue:\n        node, level = queue.popleft()\n        level_counts[level] += 1\n\n        # Get children (successors in the REVERSED graph, i.e., descendants in original)\n        if node in reversed_graph:\n            for child in reversed_graph.successors(node):\n                if child in filtered_terms and child not in term_levels:\n                    term_levels[child] = level + 1\n                    queue.append((child, level + 1))\n\n    # Handle disconnected nodes (not reachable from roots)\n    orphan_count = len([t for t in filtered_terms if t not in term_levels])\n    if orphan_count > 0:\n        print(f\"Warning: {orphan_count} terms not connected to root\")\n\n    return dict(sorted(level_counts.items())), term_levels \n\nlevel_counts, term_levels = count_go_terms_by_level(go_graph, Y_train.columns.tolist())\n\n# Create a dictionary where keys are levels and values are the corresponding target columns from Y\nlevel_to_Y = {}\ngo_terms_at_level = {}\nfor level in range(max(term_levels.values()) + 1):\n    # Get GO terms at this level\n    go_terms_at_level[level] = [go_term for go_term in Y_train.columns.tolist() if term_levels.get(go_term) == level]\n    \n    # Get column indices for these GO terms\n    #col_indices = [top_n_labels.index(go_term) for go_term in go_terms_at_level]\n    \n    # Extract corresponding columns from Y_train to create the target matrix for this level\n    level_to_Y[level] = Y_train.loc[:, go_terms_at_level[level]]\n    \n    print(f\"Level {level}: {len(go_terms_at_level[level])} GO terms, Y shape: {level_to_Y[level].shape}\")\n","metadata":{"execution":{"iopub.execute_input":"2026-04-24T02:33:30.272884Z","iopub.status.busy":"2026-04-24T02:33:30.272649Z","iopub.status.idle":"2026-04-24T02:33:34.731436Z","shell.execute_reply":"2026-04-24T02:33:34.730729Z","shell.execute_reply.started":"2026-04-24T02:33:30.272865Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Create DataLoader for training sets\nX_train = torch.tensor(train_embedding.values, dtype=torch.float32)\n\n# Convert level_to_Y dictionary of DataFrames to dictionary of tensors\nlevel_to_Y = {level: torch.tensor(df.values, dtype=torch.float32) \n                       for level, df in level_to_Y.items()}\n\n# Create a custom dataset that returns the features and a dictionary of labels\nclass HierarchicalDataset(torch.utils.data.Dataset):\n    def __init__(self, features, labels_dict):\n        self.features = features\n        self.labels_dict = labels_dict\n        self.num_samples = features.shape[0]\n        \n    def __len__(self):\n        return self.num_samples\n    \n    def __getitem__(self, idx):\n        x = self.features[idx]\n        # Create dictionary of labels for this sample at each level\n        y_dict = {level: labels[idx] for level, labels in self.labels_dict.items()}\n        return x, y_dict\n\n# Create dataset instance\ntrain_dataset = HierarchicalDataset(X_train, level_to_Y)\n\n# Create train-val split\ntrain_sub = Subset(train_dataset, train_index)\nval_sub = Subset(train_dataset, val_index)\n\n\n# OrderedDict denote the hierarchical levels and (number of classes, middle layer sizes)\nCLASSES = OrderedDict()\nfor level in sorted(level_to_Y.keys()):\n    num_classes = level_to_Y[level].shape[1]\n    if num_classes <= 10:\n        mid_size = 256  # Changed from 10\n    elif num_classes <= 100:\n        mid_size = 512  # Changed from 100\n    elif num_classes <= 1000:\n        mid_size = 2000  # Changed from 1024\n    else:\n        mid_size = 5000\n\n    CLASSES[level] = (num_classes, mid_size)\n\n# Create the model instance\nmodel = HMCN(in_dims=X_train.shape[1],\n                hidden_size=512,\n                classes=CLASSES, \n                graph=go_graph\n)\nmodel.to(device)\nprint(\"Model on gpu\", next(model.parameters()).is_cuda)\nprint(\"Total model parameters:\", sum(p.numel() for p in model.parameters())/1000000, \"million\")\n","metadata":{"execution":{"iopub.execute_input":"2026-04-24T02:33:45.901684Z","iopub.status.busy":"2026-04-24T02:33:45.901358Z","iopub.status.idle":"2026-04-24T02:33:49.355125Z","shell.execute_reply":"2026-04-24T02:33:49.354477Z","shell.execute_reply.started":"2026-04-24T02:33:45.901663Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## **5.3 Model training**","metadata":{}},{"cell_type":"code","source":"#Define Hyperparameters\nNUM_EPOCHS = 100\nBATCH_SIZE = 512  \n\n#Adam optimizer parameters\nLR = 0.005\nWEIGHT_DECAY = 1e-5\nBETA1 = 0.9\nBETA2 = 0.999\n\n# Model Loss function parameters\nALPHA = 0.25 \nGAMMA = 2\nHIER_VIOL = 0.1","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"#Define the optimizer and loss function\noptimizer = torch.optim.Adam(model.parameters(), lr=LR, weight_decay=WEIGHT_DECAY, betas=(BETA1, BETA2))\n\n# Define DataLoaders \ntrain_loader = DataLoader(train_sub, batch_size=BATCH_SIZE, shuffle=True)\nval_loader = DataLoader(val_sub, batch_size=BATCH_SIZE, shuffle=False)\n\n# Initialize loss history to track total loss and level-specific losses\nloss_history = {\n    'total_loss': {epoch + 1: [] for epoch in range(NUM_EPOCHS)},\n    'level_losses': {epoch + 1: {level_name: [] for level_name in CLASSES.keys()} for epoch in range(NUM_EPOCHS)},\n    'hierarchical_violation': {epoch + 1: [] for epoch in range(NUM_EPOCHS)}\n}\n\nfor epoch in range(NUM_EPOCHS):\n    model.train()\n    total_loss = 0.0\n    level_losses_sum = {level_name: 0.0 for level_name in CLASSES.keys()}\n    hier_viol_sum = 0.0\n    num_of_batches = 0\n     \n    # Create progress bar\n    pbar = tqdm(train_loader, desc=f\"Training for Epoch {epoch+1}/{NUM_EPOCHS}\")\n\n    for i, (x, labels) in enumerate(pbar):\n\n        x = x.to(device)\n        labels = {key: value.to(device) for key, value in labels.items()}\n\n        # Clear gradients w.r.t. parameters\n        optimizer.zero_grad()\n        \n        #create logits output based on input features\n        logits = model(x.float())\n\n        #Compute the loss\n        losses = model.loss(logits, labels, alpha = ALPHA, gamma = GAMMA, hier_viol = HIER_VIOL)\n        loss = losses['total_loss']\n\n        # Backpropagation step\n        loss.backward()\n        optimizer.step()\n\n        #Keep track of the level losses and total loss\n        num_of_batches += 1\n        total_loss += loss.item()\n        average_loss = total_loss / (num_of_batches * BATCH_SIZE)\n        loss_history['total_loss'][epoch + 1].append(average_loss)\n        \n        # Track individual level losses\n        for level in CLASSES.keys():\n            level_losses_sum[level] += losses[level].item() \n            avg_level_loss = level_losses_sum[level] / (num_of_batches * BATCH_SIZE)\n            loss_history['level_losses'][epoch + 1][level].append(avg_level_loss)\n        \n        # Track hierarchical violation if present\n        if 'hierarchical_violation' in losses:\n            hier_viol_sum += losses['hierarchical_violation'].item()\n            avg_hier_viol = hier_viol_sum / (num_of_batches * BATCH_SIZE)\n            loss_history['hierarchical_violation'][epoch + 1].append(avg_hier_viol)\n\n        # Update progress bar with current loss\n        pbar.set_postfix({'avg_loss': f'{average_loss:.4f}', 'hier_viol': f'{avg_hier_viol:.4f}' if 'hierarchical_violation' in losses else 'N/A'})\n","metadata":{"execution":{"iopub.execute_input":"2026-04-24T02:45:41.558939Z","iopub.status.busy":"2026-04-24T02:45:41.558646Z","iopub.status.idle":"2026-04-24T02:45:41.620745Z","shell.execute_reply":"2026-04-24T02:45:41.619779Z","shell.execute_reply.started":"2026-04-24T02:45:41.558919Z"},"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"code","source":"fig, axes = plt.subplots(1, 2, figsize=(18, 6))\n\n# Plot total loss across epochs\nepochs = list(loss_history['total_loss'].keys())\navg_total_loss = [np.mean(loss_history['total_loss'][e]) for e in epochs]\n\naxes[0].plot(epochs, avg_total_loss, marker='o', linewidth=2, markersize=4)\naxes[0].set_title('Total Loss Across Epochs')\naxes[0].set_xlabel('Epoch')\naxes[0].set_ylabel('Average Loss')\naxes[0].grid(True)\n\n# Plot level-specific losses across epochs\nfor level in CLASSES.keys():\n    avg_level_loss = [np.mean(loss_history['level_losses'][e][level]) for e in epochs]\n    axes[1].plot(epochs, avg_level_loss, marker='o', linewidth=2, markersize=4, label=f'Level {level}')\n\naxes[1].set_title('Level-Specific Losses Across Epochs')\naxes[1].set_xlabel('Epoch')\naxes[1].set_ylabel('Average Loss')\naxes[1].legend(bbox_to_anchor=(1.05, 1), loc='upper left')\naxes[1].grid(True)\n\nplt.tight_layout()\nplt.show()","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"## 5.4. Model Validation ","metadata":{}},{"cell_type":"code","source":"#Load the trained model from checkpoint\n#model.load_state_dict(torch.load('/kaggle/input/datasets/guojun1/t5-embedding/hmcn_model_best_params_fused.pth'))\n\n# Evaluate the model on the validation set and calculate f-max score\nmodel.eval()\n\nwith torch.no_grad():\n    all_outputs = pd.DataFrame()\n    for batch, _ in val_loader:\n        batch = batch.to(device)\n        logits = model(batch)\n\n        fused_logits = {}\n        for level in logits['local_logits'].keys():\n            #compute the fused logits as a weighted average of local and global logits\n            fused_logits[level] = logits['local_logits'][level] * 0.5 + logits['global_logits'][level] * 0.5\n\n        predictions = pd.DataFrame()\n        for level in sorted(fused_logits.keys()):\n            #Apply sigmoid to get probabilities\n            probs = torch.sigmoid(fused_logits[level]).cpu().numpy()\n            #obtain the column names (GO terms) for this level\n            column_names = go_terms_at_level[level]\n            predictions_level = pd.DataFrame(probs, columns=column_names)\n\n            predictions = pd.concat([predictions, predictions_level], axis=1)\n        \n        all_outputs = pd.concat([all_outputs, predictions], axis=0)\n\nall_outputs.index = val_protein_ids\nall_outputs = all_outputs.stack()\nall_outputs = all_outputs[all_outputs > 0.09]\n\n#save a temp file for CAFA evaluation\nos.makedirs(\"/kaggle/working/validation\",exist_ok=True)\nall_outputs.to_csv(\"/kaggle/working/validation/validation_result.tsv\", sep='\\t', index=True, header=False)\ndel all_outputs","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"def prepare_cafa_evaluation_file(train_terms_path, val_protein_ids):\n    #Save the validation terms for CAFA evaluation\n    train_terms_df = pd.read_csv(train_terms_path, sep='\\\\t')\n    val_train_terms_filtered_df = train_terms_df[train_terms_df[\"EntryID\"].isin(val_protein_ids)]\n    val_train_terms_filtered_df.to_csv(\"/kaggle/working/validation_terms.tsv\", sep='\\t', index=False, header=False)\n\nprepare_cafa_evaluation_file(\"/kaggle/input/datasets/guojun1/t5-embedding/train_terms_propagated.tsv\", val_protein_ids)\n\n# Calculate f-max score on the validation results using the CAFA evaluation script.\n_, best = cafa_eval(\n    \"/kaggle/input/competitions/cafa-6-protein-function-prediction/Train/go-basic.obo\", \n    \"/kaggle/working/validation\", \n    \"/kaggle/working/validation_terms.tsv\",  \n    ia=\"/kaggle/input/competitions/cafa-6-protein-function-prediction/IA.tsv\", \n    th_step = 0.05,\n    n_cpu=2\n)\n\nprint(\"Best weighted F-max score on validation set:\")\nprint(best['f_w']['f_w'])\n\nprint(\"And best F-max score on validation set:\")\nprint(best['f']['f'])","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"Best weighted F-max score on validation set:\n| filename    | ns                  | tau  | weighted F-max |\n|-------------|---------------------|------|----------------|\n| valfile.tsv | biological_process  | 0.30 | 0.434555       |\n| valfile.tsv | cellular_component  | 0.30 | 0.596664       |\n| valfile.tsv | molecular_function  | 0.35 | 0.649506       |\n\nAnd best F-max score on validation set:\n| filename    | ns                  | tau  | F-max    |\n|-------------|---------------------|------|----------|\n| valfile.tsv | biological_process  | 0.35 | 0.506720 |\n| valfile.tsv | cellular_component  | 0.35 | 0.727121 |\n| valfile.tsv | molecular_function  | 0.35 | 0.744495 |\n\nTable1: Model performance in terms of F-max and weighted F-max score","metadata":{}},{"cell_type":"markdown","source":"# 6. Test prediction (Final submission)\n\nFirst, we generate the same ProtT5 embeddings for the test sequences that we used for training. As previously discussed, this step is simulated by loading a pre-computed embedding file from the Kaggle database. \n\nThe final submission file must be a tab-separated `.tsv` file without a header, containing three columns: `Protein ID`, `GO Term ID`, and `Probability Score`. We will filter out any predictions below a minimal threshold ($< 0.05$) to keep the file size manageable, adhering to the limit of 1500 terms per protein.","metadata":{}},{"cell_type":"code","source":"# ==============================================================================\n# PREDICTION ON TEST SET\n# ==============================================================================\n\n#Load the trained model from checkpoint\n#model.load_state_dict(torch.load('/kaggle/input/datasets/guojun1/t5-embedding/hmcn_model_best_params_fused.pth'))\n\n#Load the test set embeddings\nX_test = pd.read_pickle(\"/kaggle/input/datasets/guojun1/t5-embedding/test_protT5_embeddings.pkl\")\nprotein_ids = X_test.index.tolist()\nprint(f\"Test feature matrix X_test created with shape: {X_test.shape}\")\n\n#Convert to tensor\nX_test = torch.tensor(X_test.values, dtype=torch.float32)\n\n# Create DataLoader for test set\nBATCH_SIZE = 512\ntest_loader = torch.utils.data.DataLoader(X_test, batch_size=BATCH_SIZE, shuffle=False)\n","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"#Script to run prediction on the test set and write results to a file in the required format for CAFA submission.\n\noutput_file = \"submission.tsv\"\nthreshold = 0.05\n\nmodel.eval()\nwith torch.no_grad():\n    for batch_idx, batch in enumerate(tqdm(test_loader, desc=\"Predicting and writing to file\")):\n        # Run prediction for the current batch\n        batch = batch.to(device)\n        logits = model(batch)\n        #Obtain the fused logits of each level\n        fused_logits = logits['fused_logits']\n\n\n        # Get protein IDs for this batch\n        batch_start = batch_idx * BATCH_SIZE\n        batch_end = min(batch_start + BATCH_SIZE, len(protein_ids))\n        batch_protein_ids = protein_ids[batch_start:batch_end]\n\n        predictions = pd.DataFrame()\n        for level in sorted(fused_logits.keys()):\n            #Apply sigmoid to get probabilities\n            probs = torch.sigmoid(fused_logits[level]).cpu().numpy()\n            #obtain the column names (GO terms) for this level\n            column_names = go_terms_at_level[level]\n            predictions_level = pd.DataFrame(probs, index=batch_protein_ids, columns=column_names)\n\n            predictions = pd.concat([predictions, predictions_level], axis=1)\n\n\n        #Apply thresholding\n        predictions = predictions.stack()\n        predictions = predictions[predictions > threshold]\n\n\n        # Group by protein_id and select top 1500 predictions per protein\n        predictions = predictions.groupby(level=0, group_keys=False).apply(lambda x: x.nlargest(1500))\n\n\n        with open(output_file, 'a') as f:\n            for (protein_id, go_term), score in predictions.items():\n                f.write(f\"{protein_id}\\t{go_term}\\t{score:.3f}\\n\")\n\nprint(f\"Predictions written to {output_file}\")","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"code","source":"!head submission.tsv","metadata":{},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# **7. Conclusion and Future Work**\n\nThis notebook has presented a complete, end-to-end framework for the CAFA 6 Protein Function Prediction challenge. Our methodology successfully leveraged the rich feature representations from the ProtT5 protein language model and combined them with a hierarchical classification network. Our approach yielded state-of-the-art performance (Table 1). \n\nWhile this framework provides a strong performance, I see several avenues for future improvement:\n1.  **Multi-Modal Feature Fusion:** The current model relies exclusively on sequence embeddings. Incorporating additional data sources, such as protein-protein interaction networks and structural information derived from AlphaFold, may significantly enhance predictive performance.\n\n2. **Positive-unlabeled (PU) learning**  In our training dataset, the absence of a GO term association for a given protein does not necessarily imply that the protein lacks the corresponding function.  The ground truth is only partial and dynamic—it is updated after each new study is published. Implementing Positive-Unlabeled (PU) learning methods could be advantageous in this context and may lead to improved model accuracy.\n\nFurthermore, we identified specific strategies that did not yield the anticipated improvements in model performance:\n\n1. The integration of embeddings from various protein language models (e.g., ProtT5, ESM-2, Ankh) and their ensembles did not result in the performance gains we had initially hypothesized.\n\n2. The addition of species information as a supplementary feature also proved ineffective.\n\n3. The implementation of the previously published model, Panda-3D [12], resulted in only moderate performance levels, comparable to a vanilla neural network, which fell short of the authors' claims. \n","metadata":{}},{"cell_type":"markdown","source":"# References \n[1] Radivojac, P., et al. (2013). A large-scale evaluation of computational protein function prediction. Nature Methods, 10(3), 221-227. doi:10.1038/nmeth.2340\n\n[2] Zhou, N., et al. (2019). The CAFA challenge reports improved protein function prediction and new functional annotations for hundreds of genes through experimental screens. Genome Biology, 20(1), 244. doi:10.1186/s13059-019-1835-8\n\n[3] Jiang, Y., et al. (2016). An expanded evaluation of protein function prediction methods shows an improvement in accuracy. Genome Biology, 17(1), 184. doi:10.1186/s13059-016-1037-6\n\n[4] Radivojac P. A (not so) quick introduction to protein function prediction. Indiana University, USA. 2013 Sep 27.\n\n[5] Elnaggar, A., Heinzinger, M., Dallago, C., Rehawi, G., Wang, Y., Jones, L., Gibbs, T., Feher, T., Angerer, C., Steinegger, M. and Bhowmik, D., 2020. ProtTrans: Towards cracking the language of life’s code through self-supervised learning.\n\n[6] Vaswani, A. et al. Attention Is All You Need. Preprint at https://doi.org/10.48550/arXiv.1706.03762 (2023).\n\n[7] Rives, A. et al. Biological structure and function emerge from scaling unsupervised learning to 250 million protein sequences. Proc Natl Acad Sci U S A 118, e2016239118 (2021).\n\n[8] Lin, Z. et al. Evolutionary-scale prediction of atomic-level protein structure with a language model. Science 379, 1123–1130 (2023).\n\n[9] Wehrmann, J., Cerri, R. & Barros, R. Hierarchical Multi-Label Classification Networks. in Proceedings of the 35th International Conference on Machine Learning 5075–5084 (PMLR, 2018).\n\n[10]Kingma, D.P. and Ba, J., 2014. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980.\n\n[11] Lin, T.-Y., Goyal, P., Girshick, R., He, K. & Dollár, P. Focal Loss for Dense Object Detection. Preprint at https://doi.org/10.48550/arXiv.1708.02002 (2018).\n\n[12] Zhao, C., Liu, T. and Wang, Z., 2024. PANDA-3D: protein function prediction based on AlphaFold models. NAR genomics and bioinformatics, 6(3), p.lqae094.\n\n\n\n","metadata":{}}]}