import torch import matplotlib.pyplot as plt import seaborn as sns import numpy as np import os import sys from transformers import AutoTokenizer # Add src to sys.path to allow imports from src/model.py and src/dataset.py sys.path.append(os.path.join(os.path.dirname(__file__), 'src')) # Import your modules from model import TaxonomyAwareESM from dataset import ProteinTaxonomyDataset def analyze_attention(checkpoint_path, data_path, target_ids, device='cuda'): print(f"=== Loading Checkpoint: {checkpoint_path} ===") # 1. Load Model Architecture checkpoint = torch.load(checkpoint_path, map_location=device) state_dict = checkpoint.get('model_state_dict', checkpoint) # Handle full checkpoint vs state dict only # Infer num_classes from the classifier weights in state_dict # Model definition: self.classifier = nn.Linear(..., num_classes) # So key is 'classifier.weight' if 'classifier.weight' in state_dict: num_classes = state_dict['classifier.weight'].shape[0] elif 'classifier.3.weight' in state_dict: # Keeping fallback if user had MLP before num_classes = state_dict['classifier.3.weight'].shape[0] else: # Try to guess or fail print("Warning: Could not infer num_classes from state_dict keys. Keys:", state_dict.keys()) raise KeyError("Could not find classifier weights") print(f"Detected Num Classes: {num_classes}") model = TaxonomyAwareESM( num_classes=num_classes, pretrained_model_name="facebook/esm2_t6_8M_UR50D", freeze_backbone=True ) model.load_state_dict(state_dict, strict=False) # STRICT=FALSE because we might miss some metadata model.to(device) model.eval() # 2. Hook Cross-Attention to capture weights attn_weights_storage = {} def get_attn_weights(name): def hook(module, input, output): # output of MultiheadAttention is (attn_output, attn_output_weights) # attn_output_weights shape: [Batch, Target_Len, Source_Len] # Here: [1, Seq_Len, 7] (7 is Taxonomy Ranks) # Note: batch_first=True in model definition attn_weights_storage[name] = output[1].detach().cpu() return hook model.cross_attention.register_forward_hook(get_attn_weights('cross_attn')) # 3. Load Samples from Large Learning Superset print("Loading dataset...") # Setup Paths fasta_path = os.path.join(data_path, "learning_superset", "large_learning_superset.fasta") term_path = os.path.join(data_path, "learning_superset", "large_learning_superset_term.tsv") species_vec = os.path.join(data_path, "taxon_embedding", "species_vectors.tsv") go_vocab = os.path.join("src", "go_terms.json") # Relative to root tokenizer = AutoTokenizer.from_pretrained("facebook/esm2_t6_8M_UR50D") # Lightweight dataset init # Note: parsing the huge fasta might take a moment. # To be faster, we could scan for the IDs first, but ProteinTaxonomyDataset loads everything. # Given the constraints, let's load it. dataset = ProteinTaxonomyDataset( fasta_path, term_path, species_vec, go_vocab, max_len=512, esm_tokenizer=tokenizer ) print(f"Dataset loaded. Total samples: {len(dataset)}") # Filter for target IDs target_indices = [] # We need to map ID to index. # Dataset doesn't expose a quick map, so we iterate. # This might be slow for 75MB fasta, but acceptable for a one-off script. print(f"Searching for target IDs: {target_ids}") found_count = 0 # Optimally, we access dataset information if available. # Checking dataset implementation... unique_ids list usually exists. if hasattr(dataset, 'protein_ids'): for idx, pid in enumerate(dataset.protein_ids): if pid in target_ids: target_indices.append(idx) found_count += 1 else: # Fallback: iterate (slower) for i in range(len(dataset)): if dataset[i]['entry_id'] in target_ids: target_indices.append(i) found_count += 1 if found_count >= len(target_ids): break print(f"Found {len(target_indices)} samples matching targets.") # Create output directory output_dir = os.path.join("outputs", "attention_map") os.makedirs(output_dir, exist_ok=True) for idx in target_indices: sample = dataset[idx] # Prepare batch input_ids = sample['input_ids'].unsqueeze(0).to(device) attention_mask = sample['attention_mask'].unsqueeze(0).to(device) tax_vector = sample['tax_vector'].unsqueeze(0).to(device) prot_id = sample.get('entry_id', 'Unknown') print(f"Analyzing Protein ID: {prot_id}") # 4. Forward Pass # Clear previous hooks just in case attn_weights_storage.clear() with torch.no_grad(): _ = model(input_ids, attention_mask, tax_vector) # 5. Visualize if 'cross_attn' not in attn_weights_storage: print(f"Error: Hook did not capture attention weights for {prot_id}.") continue # attn_weights shape: [1, Seq_Len, 7] weights = attn_weights_storage['cross_attn'][0] # Remove batch dim -> [Seq_Len, 7] # Remove padding from visualization seq_len = attention_mask.sum().item() weights = weights[:seq_len, :] # [Real_Seq_Len, 7] # Plot plt.figure(figsize=(12, 8)) # Transpose for easier reading: Y-axis = Taxonomy Ranks, X-axis = Sequence Position sns.heatmap(weights.T.numpy(), cmap='viridis', yticklabels=["Kingdom", "Phylum", "Class", "Order", "Family", "Genus", "Species"]) plt.title(f"Cross-Attention Map - Protein {prot_id}") plt.xlabel("Sequence Position (Residues)") plt.ylabel("Taxonomic Rank") save_path = os.path.join(output_dir, f"{prot_id}.png") plt.savefig(save_path) plt.close() # Close plot to save memory print(f"Analysis saved to {save_path}") print("\n[Interpretation Guide]") print("- Uniform Color? -> Model hasn't learned to distinguish ranks yet.") print("- Vertical Stripes? -> Specific residues attend to ALL ranks (Structural importance).") print("- Horizontal Stripes? -> Some ranks are universally more important.") print("- Scattered Hotspots? -> IDEAL. Specific residues attend to specific ranks.") if __name__ == "__main__": # Target IDs from earlier investigation of large_learning_superset.fasta targets = [ "P0DPQ6", "A0A0C5B5G6", "P40205", "F5H094", "Q6RFH8", "Q0D2H9", "L0R8F8", "P0DMW2", "Q6L8H1", "A0A1B0GTW7" ] analyze_attention( checkpoint_path="outputs/best_model_fmax.pth", data_path=".", target_ids=targets, device='cuda' if torch.cuda.is_available() else 'cpu' )