Upload folder using huggingface_hub

.gitattributes

@@ -68,3 +68,5 @@ outputs/gpu_preds_homolog_epoch_10.tsv filter=lfs diff=lfs merge=lfs -text
 outputs/gpu_preds_homolog_epoch_3.tsv filter=lfs diff=lfs merge=lfs -text
 outputs/gpu_preds_novel_epoch_10.tsv filter=lfs diff=lfs merge=lfs -text
 outputs/gpu_preds_novel_epoch_3.tsv filter=lfs diff=lfs merge=lfs -text
+go-basic.obo filter=lfs diff=lfs merge=lfs -text
+ta_esm2_submission.tsv filter=lfs diff=lfs merge=lfs -text

go-basic.obo

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

process_submission.py

@@ -0,0 +1,237 @@
+
+import sys
+import argparse
+import networkx as nx
+import obonet
+import csv
+from tqdm import tqdm
+import math
+import os
+
+# Increase CSV field size limit (Windows compatibility: use 2**31-1)
+csv.field_size_limit(2147483647)
+
+def load_dag(obo_path):
+    print(f"Loading OBO file from {obo_path}...")
+    graph = obonet.read_obo(obo_path)
+    print(f"DAG loaded. Nodes: {len(graph)}, Edges: {len(graph.edges)}")
+    
+    # 1. Parents Map (Child -> Parents)
+    # obonet: edge is Child -> Parent ('is_a')
+    parents_map = {n: list(graph.successors(n)) for n in graph.nodes()}
+    
+    # 2. Ancestors Map (Child -> All Ancestors) for fast active set expansion
+    # This takes a few seconds for 47k nodes.
+    print("Pre-computing ancestor maps...")
+    ancestors_map = {}
+    for node in graph.nodes():
+        ancestors_map[node] = nx.ancestors(graph, node)
+        
+    return graph, parents_map, ancestors_map
+
+def process_single_protein(entries, parents_map, ancestors_map, topo_order, alpha, power):
+    # 1. Init Scores
+    # We must track all 'active' nodes (input terms + their ancestors)
+    # Use a dictionary {GO: score}. Default 0.
+    
+    scores = {}
+    for term, score in entries:
+        scores[term] = max(scores.get(term, 0.0), score) # Handle duplicate lines if any
+        
+    # Expand to ancestors
+    # Only necessary if positive propagation needs them explicitly
+    # But usually we just want to ensure parents exist in dict if we are boosting them.
+    # Let's collect all involved nodes.
+    
+    active_keys = list(scores.keys())
+    for term in active_keys:
+        # Add all ancestors with 0.0 if not present
+        # This is important so Positive prop can boost them from 0 to Child_Score
+        if term in ancestors_map:
+            for anc in ancestors_map[term]:
+                if anc not in scores:
+                    scores[anc] = 0.0
+                    
+    # Now we have a sparse dict 'scores' containing ~50-100 terms.
+    # We want to propagate on this subgraph.
+    
+    # Create a sorted list of active nodes based on global topo_order
+    # Global topo_order is [Child, ..., Parent]
+    # Filter global list to current keys
+    # Optimization: Sorting the keys by their index in global topo might be slow if map is big O(N).
+    # N=47k. 
+    # Faster: Assign rank to each node once globally. 
+    # Then sort active_nodes by rank.
+    # We'll assume 'topo_order' passed in is a dict {Node: Rank}.
+    
+    # Sort active nodes
+    # If a node is missing from topo_order (e.g. obsolete), ignore or put at end?
+    # Put at end implies it's a root or disconnected? 
+    # Safe to ignore order for unknown nodes, or sort by name?
+    # Let's simple sort:
+    active_nodes = sorted(scores.keys(), key=lambda n: topo_order.get(n, 0)) # Rank 0 = Leaf-ish?
+    # Wait, nx.topological_sort gives [Leaf, ..., Root] (if Child->Parent edges).
+    # So index 0 is Leaf. Index N is Root.
+    
+    # ---------------------------------------------------------
+    # Step 1: Positive Propagation (Child -> Parent)
+    # Iterate from Child to Parent (index 0 -> N).
+    # For each node, propagate its score to its immediate parents.
+    # ---------------------------------------------------------
+    for node in active_nodes:
+        my_score = scores[node]
+        if my_score <= 0: continue
+            
+        if node in parents_map:
+            for parent in parents_map[node]:
+                # Update parent max
+                # Only update if parent is tracked (it should be, due to ancestor expansion)
+                if parent in scores:
+                    scores[parent] = max(scores[parent], my_score)
+                else:
+                    # Should not happen if ancestors_map was correct
+                    pass
+                    
+    # ---------------------------------------------------------
+    # Step 2: Negative Propagation (Parent -> Child)
+    # Iterate from Parent to Child (index N -> 0).
+    # Logic: Child = Child * (Parent * Alpha + (1-Alpha))
+    # Note: A node may have multiple parents. Which one controls?
+    # Usually 'consistent' means <= min(parents).
+    # If we use the soft formula, we need to defined 'Parent Score'.
+    # Max(parents)? Min(parents)? Avg?
+    # Standard consistency requires <= all parents. So we use MIN of all parents.
+    # If a root node, Parent Score = 1.0.
+    # ---------------------------------------------------------
+    
+    # Iterate backwards
+    for node in reversed(active_nodes):
+        if node not in parents_map or not parents_map[node]:
+            # Root node (or no parents in active set?)
+            # If root, implicit parent is 1.0.
+            # No change needed.
+            continue
+            
+        # Get parent scores
+        parent_scores = []
+        for p in parents_map[node]:
+            if p in scores:
+                parent_scores.append(scores[p])
+            else:
+                # Parent not in active set? 
+                # Should not happen (ancestors expanded).
+                # Assume 0.0? Or 1.0? 
+                # If ancestor expansion worked, p should be in scores.
+                # If p is not in scores, it's not a GO term (maybe).
+                pass
+        
+        if not parent_scores:
+            continue
+            
+        # Using MIN parent score as the limiting factor
+        min_parent_score = min(parent_scores)
+        
+        # Formula: Child = Child * (P * alpha + (1-alpha))
+        # If P=1, Factor=1. If P=0, Factor=1-alpha.
+        factor = min_parent_score * alpha + (1.0 - alpha)
+        
+        scores[node] = scores[node] * factor
+        
+    # ---------------------------------------------------------
+    # Step 3: Power Scaling
+    # ---------------------------------------------------------
+    results = {}
+    for term, osc in scores.items():
+        if osc > 0:
+            # Power
+            final = math.pow(osc, power)
+            results[term] = final
+            
+    return results
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('input_file')
+    parser.add_argument('output_file')
+    parser.add_argument('--obo', required=True)
+    parser.add_argument('--alpha', type=float, default=0.7)
+    parser.add_argument('--power', type=float, default=2.0)
+    args = parser.parse_args()
+    
+    # 1. Load Dag
+    graph, parents_map, ancestors_map = load_dag(args.obo)
+    
+    # 2. Topo Rank
+    print("Computing topological sort rank...")
+    try:
+        topo_list = list(nx.topological_sort(graph))
+    except nx.NetworkXUnfeasible:
+        print("Warning: Cycle detected. Using imprecise sort.")
+        topo_list = list(graph.nodes())
+        
+    # Map Node -> Rank (Index)
+    topo_rank = {node: i for i, node in enumerate(topo_list)}
+    
+    # 3. Stream
+    # Estimate lines
+    try:
+        # Windows specific quick size check?
+        # just assume large. 100M lines.
+        est_lines = 112000000
+    except:
+        est_lines = 0
+        
+    print(f"Streaming {args.input_file} -> {args.output_file}...")
+    
+    with open(args.input_file, 'r') as fin, open(args.output_file, 'w', newline='') as fout:
+        reader = csv.reader(fin, delimiter='\t')
+        writer = csv.writer(fout, delimiter='\t')
+        
+        current_protein = None
+        current_entries = []
+        count = 0
+        
+        pbar = tqdm(total=est_lines, unit="line")
+        
+        for row in reader:
+            pbar.update(1)
+            if not row: continue
+            
+            # Submission format: ProteinID, GO, Score
+            # If duplicates exist, we handle in process_single_protein
+            p_id, go_id, score_str = row[0], row[1], row[2]
+            try:
+                score = float(score_str)
+            except ValueError:
+                continue # Skip header or bad lines
+                
+            if p_id != current_protein:
+                if current_protein is not None:
+                    # Process
+                    res_dict = process_single_protein(current_entries, parents_map, ancestors_map, topo_rank, args.alpha, args.power)
+                    # Write
+                    # Filter low scores? CAFA usually keeps top N or > threshold.
+                    # We output all non-zero.
+                    for term, val in res_dict.items():
+                        if val > 0.001: # Optimization: drop very low
+                            writer.writerow([current_protein, term, f"{val:.6f}"])
+                    count += 1
+                
+                current_protein = p_id
+                current_entries = []
+                
+            current_entries.append((go_id, score))
+            
+        # Last one
+        if current_protein is not None:
+            res_dict = process_single_protein(current_entries, parents_map, ancestors_map, topo_rank, args.alpha, args.power)
+            for term, val in res_dict.items():
+                if val > 0.001:
+                    writer.writerow([current_protein, term, f"{val:.6f}"])
+            count += 1
+            
+        pbar.close()
+        print(f"Finished. Processed {count} unique proteins.")
+
+if __name__ == "__main__":
+    main()

ta_esm2_submission.tsv

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