import torch import torch.nn as nn from transformers import EsmModel, EsmConfig from typing import Optional from peft import get_peft_model, LoraConfig, TaskType class TaxonomyAwareESM(nn.Module): def __init__(self, num_classes, pretrained_model_name="facebook/esm2_t33_650M_UR50D", use_lora=True, lora_rank=8, vocab_sizes=None): super().__init__() # 1. ESM Backbone print(f"Loading ESM model: {pretrained_model_name}") self.esm = EsmModel.from_pretrained(pretrained_model_name) if use_lora: print(f"Injecting LoRA adapters (Rank={lora_rank})...") # Define configuration peft_config = LoraConfig( task_type=TaskType.FEATURE_EXTRACTION, inference_mode=False, r=lora_rank, # Intrinsic Rank lora_alpha=32, # Scaling Factor lora_dropout=0.1, target_modules=["query", "value"] ) # Wrap the model self.esm = get_peft_model(self.esm, peft_config) self.esm.print_trainable_parameters() else: # Traditional Freezing for param in self.esm.parameters(): param.requires_grad = False self.hidden_dim = self.esm.config.hidden_size # e.g. 1280 for 650M # 2. Taxonomy Encoder # Ranks: Phylum, Class, Order, Family, Genus, Species, Subspecies (7 levels) if vocab_sizes is None: # Fallback to defaults if not provided (though train.py should pass them) # Using sufficiently large defaults relative to known biology data print("Warning: vocab_sizes not provided, using hardcoded defaults.") self.vocab_sizes = [1000, 5000, 10000, 20000, 50000, 100000, 50000] else: self.vocab_sizes = vocab_sizes print(f"Model initialized with vocab sizes: {self.vocab_sizes}") self.tax_embedding_dim = 128 # Dimension for tax embeddings self.tax_embeddings = nn.ModuleList([ nn.Embedding(self.vocab_sizes[i], self.tax_embedding_dim, padding_idx=0) for i in range(len(self.vocab_sizes)) ]) # Project combined tax embeddings (7 * 128) to match ESM dim? # Or project ESM to match Tax? # Goal: Cross Attention using Sequence as Query, Tax as Key/Value. # Sequence (B, L, D_esm) # Tax (B, 7, D_tax) self.tax_projector = nn.Linear(self.tax_embedding_dim, self.hidden_dim) # 3. Cross Attention Fusion # Query: Protein Sequence (B, L, H) # Key/Value: Taxonomy Info (B, 7, H) # Output: Enhanced Sequence (B, L, H) self.cross_attention = nn.MultiheadAttention(embed_dim=self.hidden_dim, num_heads=8, batch_first=True) self.layer_norm = nn.LayerNorm(self.hidden_dim) self.dropout = nn.Dropout(0.1) # 4. Classifier Head # Pooling? "Mean Pooling" or "CLS". ESM has CLS. # Let's use Mean Pooling of the Fused Sequence representation. self.classifier = nn.Linear(self.hidden_dim, num_classes) def forward(self, input_ids, attention_mask, tax_vector): """ input_ids: (B, L) attention_mask: (B, L) tax_vector: (B, 7) """ # 1. Forward ESM outputs = self.esm(input_ids=input_ids, attention_mask=attention_mask) sequence_output = outputs.last_hidden_state # (B, L, H) # 2. Forward Taxonomy # tax_vector is (B, 7) integers. # We need to embed each column with its specific embedding layer. tax_embeds = [] for i in range(7): idx = tax_vector[:, i] # (B,) # Clamp to vocab size to avoid index out of bounds if new species appear? # Or assume 0 (UNK) handling upstream. # Ideally safety check: idx = idx.clamp(0, self.vocab_sizes[i] - 1) emb = self.tax_embeddings[i](idx) # (B, D_tax) tax_embeds.append(emb) # Stack to get (B, 7, D_tax) tax_sequence = torch.stack(tax_embeds, dim=1) # (B, 7, D_tax) # Project to match ESM dim tax_sequence = self.tax_projector(tax_sequence) # (B, 7, H) # 3. Cross Attention # Query: Sequence (B, L, H) # Key: Tax (B, 7, H) # Value: Tax (B, 7, H) # We want to inject Tax info into Sequence. attn_output, _ = self.cross_attention( query=sequence_output, key=tax_sequence, value=tax_sequence ) # Residual Connection + Norm # fused_sequence = LayerNorm(Sequence + Dropout(Attn)) fused_sequence = self.layer_norm(sequence_output + self.dropout(attn_output)) # 4. Pooling # Masked Mean Pooling mask_expanded = attention_mask.unsqueeze(-1).expand(fused_sequence.size()).float() sum_embeddings = torch.sum(fused_sequence * mask_expanded, dim=1) sum_mask = torch.clamp(mask_expanded.sum(dim=1), min=1e-9) pooled_output = sum_embeddings / sum_mask # (B, H) # 5. Classifier logits = self.classifier(pooled_output) # (B, NumClasses) return logits class AsymmetricLoss(nn.Module): def __init__(self, gamma_neg=4, gamma_pos=0, clip=0.05, eps=1e-8, disable_torch_grad_focal_loss=True, reduction='mean', ic_weights: Optional[torch.Tensor] = None, normalize_ic: bool = True): super(AsymmetricLoss, self).__init__() self.gamma_neg = gamma_neg self.gamma_pos = gamma_pos self.clip = clip self.eps = eps self.disable_torch_grad_focal_loss = disable_torch_grad_focal_loss self.reduction = reduction self.normalize_ic = normalize_ic # IC 가중치 처리 self.use_ic_weights = ic_weights is not None if self.use_ic_weights: if normalize_ic: # 0이 아닌 가중치만 사용하여 정규화 (mean=1) nonzero_mask = ic_weights > 0 if nonzero_mask.sum() > 0: nonzero_weights = ic_weights[nonzero_mask] ic_weights = ic_weights / (nonzero_weights.mean() + 1e-8) # 최소 가중치 설정 및 버퍼 등록 ic_weights = torch.clamp(ic_weights, min=0.1) self.register_buffer('ic_weights', ic_weights) print("✅ AsymmetricLoss with IC weights initialized.") print(f" IC weights range: [{self.ic_weights.min():.4f}, {self.ic_weights.max():.4f}]") def forward(self, x, y): """ Parameters ---------- x: input logits y: targets (multi-label binarized vector) """ # Calculating Probabilities x_sigmoid = torch.sigmoid(x) xs_pos = x_sigmoid xs_neg = 1 - x_sigmoid # Asymmetric Clipping if self.clip is not None and self.clip > 0: xs_neg = (xs_neg + self.clip).clamp(max=1) # Basic CE calculation los_pos = y * torch.log(xs_pos.clamp(min=self.eps)) los_neg = (1 - y) * torch.log(xs_neg.clamp(min=self.eps)) # Asymmetric Focusing if self.gamma_neg > 0 or self.gamma_pos > 0: if self.disable_torch_grad_focal_loss: torch.set_grad_enabled(False) pt0 = xs_pos * y pt1 = xs_neg * (1 - y) # pt = p if t > 0 else 1-p pt = pt0 + pt1 one_sided_gamma = self.gamma_pos * y + self.gamma_neg * (1 - y) one_sided_w = torch.pow(1 - pt, one_sided_gamma) if self.disable_torch_grad_focal_loss: torch.set_grad_enabled(True) los_pos = one_sided_w * los_pos los_neg = one_sided_w * los_neg # IC 가중치 적용 (Positive와 Negative Loss 모두에) # 평가 시 FP에도 IC 가중치가 적용되므로, 학습 시에도 일관성을 위해 negative loss에도 적용 if self.use_ic_weights: los_pos = los_pos * self.ic_weights.unsqueeze(0) los_neg = los_neg * self.ic_weights.unsqueeze(0) loss = - (los_pos + los_neg) if self.reduction == 'mean': # loss = loss.mean() loss = loss.sum() / x.size(0) elif self.reduction == 'sum': loss = loss.sum() return loss