predict_test.py

import os
import sys
import torch
import json
import argparse
import numpy as np
import pandas as pd
from torch.utils.data import Dataset, DataLoader
from tqdm import tqdm
from Bio import SeqIO
from transformers import AutoTokenizer

# Add src to path to import model
sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
from model import TaxonomyAwareESM

class InferenceDataset(Dataset):
    def __init__(self, fasta_path, species_vector_path, max_len=1024, esm_tokenizer=None):
        self.max_len = max_len
        self.tokenizer = esm_tokenizer
        
        # 1. Load Species Vectors
        print(f"Loading species vectors from {species_vector_path}...")
        self.tax_vectors = {}
        with open(species_vector_path, 'r') as f:
            for line in f:
                parts = line.strip().split('\t')
                if len(parts) >= 2:
                    tax_id = int(parts[0])
                    vector_str = parts[1]
                    vector = json.loads(vector_str) 
                    self.tax_vectors[tax_id] = vector
        
        # 2. Index Sequences
        print(f"Indexing sequences from {fasta_path}...")
        self.ids = []
        self.tax_ids = []
        self.seqs = []
        
        # Parse FASTA
        for record in SeqIO.parse(fasta_path, "fasta"):
            entry_id = self._parse_entry_id(record.id)
            tax_id = self._parse_tax_id(record.description)
            
            if tax_id is None or tax_id not in self.tax_vectors:
                # Use default/UNK if tax_id is missing or not in vectors
                 # CAFA challenge often has specific rules, but here we assume UNK
                tax_id = -1 
            
            self.ids.append(entry_id)
            self.tax_ids.append(tax_id)
            self.seqs.append(str(record.seq))
            
        print(f"Loaded {len(self.ids)} sequences.")

    def _parse_entry_id(self, header_id):
        # sp|Q69383|REC6_HUMAN -> Q69383
        parts = header_id.split('|')
        if len(parts) >= 2:
            return parts[1]
        return header_id

    def _parse_tax_id(self, header_desc):
        try:
            if "OX=" in header_desc:
                part = header_desc.split("OX=")[1].split(" ")[0]
                return int(part)
            parts = header_desc.split()
            if len(parts) >= 2:
                potential_taxid = parts[1]
                if potential_taxid.isdigit():
                    return int(potential_taxid)
            return None
        except Exception:
            return None

    def __len__(self):
        return len(self.ids)

    def __getitem__(self, idx):
        seq_str = self.seqs[idx]
        tax_id = self.tax_ids[idx]
        entry_id = self.ids[idx]
        
        encoded = self.tokenizer(
            seq_str,
            padding=False, # Dynamic padding in collate
            truncation=True,
            max_length=self.max_len,
            return_tensors='pt'
        )
        
        input_ids = encoded['input_ids'].squeeze(0)
        attention_mask = encoded['attention_mask'].squeeze(0)
        
        if tax_id in self.tax_vectors:
            tax_vector = torch.tensor(self.tax_vectors[tax_id], dtype=torch.long)
        else:
            tax_vector = torch.zeros(7, dtype=torch.long)
            
        return {
            'input_ids': input_ids,
            'attention_mask': attention_mask,
            'tax_vector': tax_vector,
            'entry_id': entry_id
        }

def get_vocab_sizes(species_vector_path):
    # Determine vocab sizes from json files in vocab/ dir
    # Same logic as dataset.py
    tax_ranks = ["phylum", "class", "order", "family", "genus", "species", "subspecies"]
    vocab_sizes = []
    
    vector_dir = os.path.dirname(species_vector_path)
    vocab_dir = os.path.join(vector_dir, "vocab")
    
    print(f"Loading taxonomy vocabs from {vocab_dir}...")
    for rank in tax_ranks:
        v_path = os.path.join(vocab_dir, f"{rank}_vocab.json")
        if os.path.exists(v_path):
            with open(v_path, 'r') as f:
                v_map = json.load(f)
                vocab_sizes.append(len(v_map) + 1)
        else:
            print(f"Warning: Vocab file {v_path} not found. Using default 1000.")
            vocab_sizes.append(1000)
    return vocab_sizes

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--test_fasta", type=str, required=True)
    parser.add_argument("--model_path", type=str, required=True)
    parser.add_argument("--output_file", type=str, required=True)
    parser.add_argument("--go_json", type=str, default="src/go_terms.json")
    parser.add_argument("--species_vec", type=str, default="dataset/taxon_embedding/species_vectors.tsv")
    parser.add_argument("--batch_size", type=int, default=256)
    parser.add_argument("--lora_rank", type=int, default=512)
    parser.add_argument("--dry_run", action="store_true")
    
    parser.add_argument("--num_workers", type=int, default=8)
    
    args = parser.parse_args()
    
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    print(f"Using device: {device}")
    
    # 1. Load GO Mappings
    print(f"Loading GO terms from {args.go_json}...")
    with open(args.go_json, 'r') as f:
        go_to_idx = json.load(f)
    idx_to_go = {v: k for k, v in go_to_idx.items()}
    num_classes = len(go_to_idx)
    
    # 2. Get Vocab Sizes
    vocab_sizes = get_vocab_sizes(args.species_vec)
    print(f"Vocab Sizes: {vocab_sizes}")
    
    # 3. Initialize Model
    print("Initialize Model...")
    # NOTE: Check if model.py requires args for use_lora or defaults?
    # Defaults in model.py are use_lora=True, rank=8. 
    # But training used 512.
    model = TaxonomyAwareESM(
        num_classes=num_classes,
        pretrained_model_name="facebook/esm2_t33_650M_UR50D",
        use_lora=True,
        lora_rank=args.lora_rank,
        vocab_sizes=vocab_sizes
    )
    
    # Load Weights
    print(f"Loading weights from {args.model_path}...")
    checkpoint = torch.load(args.model_path, map_location=device)
    # Check if state_dict is nested
    if 'model_state_dict' in checkpoint:
        state_dict = checkpoint['model_state_dict']
    else:
        state_dict = checkpoint
        
    model.load_state_dict(state_dict)
    model.to(device)
    model.eval()
    
    # 4. Tokenizer
    tokenizer = AutoTokenizer.from_pretrained("facebook/esm2_t33_650M_UR50D")
    
    # 5. Dataset & Loader
    dataset = InferenceDataset(
        args.test_fasta, 
        args.species_vec, 
        esm_tokenizer=tokenizer
    )
    
    # Collate function for dynamic padding
    def collate_fn(batch):
        # batch is list of dicts
        input_ids = [item['input_ids'] for item in batch]
        attention_mask = [item['attention_mask'] for item in batch]
        tax_vectors = [item['tax_vector'] for item in batch]
        entry_ids = [item['entry_id'] for item in batch]
        
        # Pad inputs
        input_ids_padded = torch.nn.utils.rnn.pad_sequence(input_ids, batch_first=True, padding_value=tokenizer.pad_token_id)
        attention_mask_padded = torch.nn.utils.rnn.pad_sequence(attention_mask, batch_first=True, padding_value=0)
        
        tax_vectors_stacked = torch.stack(tax_vectors)
        
        return {
            'input_ids': input_ids_padded,
            'attention_mask': attention_mask_padded,
            'tax_vector': tax_vectors_stacked,
            'entry_id': entry_ids
        }

    loader = DataLoader(
        dataset, 
        batch_size=args.batch_size, 
        shuffle=False, 
        num_workers=args.num_workers,
        pin_memory=True,
        collate_fn=collate_fn,
        persistent_workers=True if args.num_workers > 0 else False,
        prefetch_factor=2 if args.num_workers > 0 else None
    )
    

    # 6. Inference
    print(f"Starting Inference on {len(dataset)} sequences...")
    
    # Write buffer 
    buffer = []
    BUFFER_SIZE = 10000 
    
    os.makedirs(os.path.dirname(os.path.abspath(args.output_file)), exist_ok=True)
    
    # Use AMP
    scaler = torch.cuda.amp.GradScaler() # Not strictly needed for inference, but autocast is
    
    with open(args.output_file, 'w') as f:
        with torch.no_grad():
            for i, batch in enumerate(tqdm(loader)):
                if args.dry_run and i >= 2:
                    break
                    
                input_ids = batch['input_ids'].to(device)
                attention_mask = batch['attention_mask'].to(device)
                tax_vector = batch['tax_vector'].to(device)
                entry_ids = batch['entry_id']
                
                # Autocast context
                with torch.cuda.amp.autocast():
                    logits = model(input_ids, attention_mask, tax_vector)
                    probs = torch.sigmoid(logits)
                
                probs = probs.float().cpu().numpy() # Cast back to float for precision in output
                
                for j, entry_id in enumerate(entry_ids):
                    row_probs = probs[j]
                    # Top 500
                    top_k = 500
                    if len(row_probs) <= top_k:
                        top_indices = np.argsort(row_probs)[::-1]
                    else:
                        # Use argpartition for efficiency, then sort the top k
                        ind = np.argpartition(row_probs, -top_k)[-top_k:]
                        # Sort descending
                        top_indices = ind[np.argsort(row_probs[ind])][::-1]

                    for idx in top_indices:
                        score = row_probs[idx]
                        if score > 0.0:
                            term = idx_to_go[idx]
                            # Buffer lines
                            buffer.append(f"{entry_id}\t{term}\t{score:.5f}\n")
                        
                if len(buffer) >= BUFFER_SIZE:
                    f.writelines(buffer)
                    buffer = []
                    
        # Flush remaining
        if buffer:
            f.writelines(buffer)
                        
    print(f"Done. Predictions saved to {args.output_file}")


if __name__ == "__main__":
    main()