Upload folder using huggingface_hub

src/train.py

@@ -142,7 +142,7 @@ def run_evaluation(model, valid_loader, ontologies, gt, device, out_dir, epoch,
 
 def evaluate_gpu(model, dataloader, ic_weights, device, thresholds=None, pred_output_path=None, metrics_output_path=None):
     """
-    Calculates Weighted F-max using GPU streaming to avoid OOM.
+    Calculates Weighted F-max and S-min using GPU streaming to avoid OOM.
     """
     model.eval()
     
@@ -152,8 +152,8 @@ def evaluate_gpu(model, dataloader, ic_weights, device, thresholds=None, pred_ou
     # Initialize accumulators for each threshold
     sum_prec = torch.zeros(len(thresholds), device=device)
     sum_rec = torch.zeros(len(thresholds), device=device)
-    
-    total_samples = 0
+    sum_ru = torch.zeros(len(thresholds), device=device) # Remaining Uncertainty (Weighted FN)
+    sum_mi = torch.zeros(len(thresholds), device=device) # Misinformation (Weighted FP)
     
     total_samples = 0
     
@@ -162,7 +162,6 @@ def evaluate_gpu(model, dataloader, ic_weights, device, thresholds=None, pred_ou
     if pred_output_path:
         os.makedirs(os.path.dirname(pred_output_path), exist_ok=True)
         f_pred = open(pred_output_path, 'w')
-        # Need reverse mapping idx -> GO Term
         idx_to_go = {v: k for k, v in dataloader.dataset.go_to_idx.items()}
     
     with torch.no_grad():
@@ -173,89 +172,83 @@ def evaluate_gpu(model, dataloader, ic_weights, device, thresholds=None, pred_ou
             labels = batch['labels'].to(device) # (B, NumClasses)
             entry_ids = batch['entry_id']
             
-            # Debug/Fix for ID Truncation issue
-            # If entry_ids is a single string (e.g. "C0HM65") but batch > 1, iteration yields chars ('C', '0', ... '5')
-            # This causes "5" to be written as ID.
+            # --- SAME LOGIC AS BEFORE FOR ID HANDLING ---
             if isinstance(entry_ids, str):
-                # This should only happen for Batch Size 1 if standard collate returns string? 
-                # Or if something is broken.
                 entry_ids = [entry_ids]
-            
-            # Ensure it is a list/tuple
             if not isinstance(entry_ids, (list, tuple)):
-                 # Convert tensor or other to list if needed, though usually tuple/list
                  if isinstance(entry_ids, torch.Tensor):
                      entry_ids = entry_ids.tolist()
                  else:
                      entry_ids = list(entry_ids)
             
-            # Check length Consistency
-            if len(entry_ids) != input_ids.size(0):
-               # If strict mismatch, maybe we have a problem.
-               # But let's just proceed with safe iteration
-               pass
-            
             # 1. Forward
             logits = model(input_ids, attention_mask, tax_vector)
             probs = torch.sigmoid(logits) # (B, NumClasses)
             
-            # Save Predictions (Streamed)
+            # Save Predictions output logic (kept same)
             if f_pred:
                 probs_cpu = probs.cpu().numpy()
                 for i, entry_id in enumerate(entry_ids):
-                    # Sparse write: only > 0.01
                     indices = np.where(probs_cpu[i] > 0.01)[0]
                     for idx in indices:
                         term = idx_to_go[idx]
                         score = probs_cpu[i][idx]
                         f_pred.write(f"{entry_id}\t{term}\t{score:.4f}\n")
             
-            # 2. Ground Truth IC (for Recall)
+            # 2. Ground Truth IC
             # labels * weights
-            # ic_weights: (NumClasses,)
             true_ic = (labels * ic_weights).sum(dim=1) # (B,)
-            
-            # Avoid div by zero
             true_ic = torch.maximum(true_ic, torch.tensor(1e-9, device=device))
             
-            # 3. Iterate Thresholds (Vectorized over batch? RAM concern dependent)
-            # Doing it threshold-by-threshold might be slower but safer for memory if we have many thresholds.
-            # But we can broadcast: (B, 1, C) >= (1, T, 1) -> (B, T, C)
-            # (B, T, C) is 256 * 100 * 40000 * 1 bit? ~120MB. Safe.
-            
-            probs_unsqueezed = probs.unsqueeze(1) # (B, 1, C)
-            thresholds_unsqueezed = thresholds.view(1, -1, 1) # (1, T, 1)
+            # 3. Thresholding & Metrics Broadcasting
+            # (B, 1, C) >= (1, T, 1) -> (B, T, C)
+            probs_unsqueezed = probs.unsqueeze(1) 
+            thresholds_unsqueezed = thresholds.view(1, -1, 1)
             
-            # Pred Binary: (B, T, C)
             pred_binary = (probs_unsqueezed >= thresholds_unsqueezed).float()
             
-            # Weighted Intersection (TP): (B, T, C) * (B, 1, C) * (1, 1, C)
-            # We can optimize: (pred_binary * labels) -> TP
             labels_unsqueezed = labels.unsqueeze(1) # (B, 1, C)
+            ic_weights_unsqueezed = ic_weights.view(1, 1, -1) # (1, 1, C)
             
-            # Intersection IC: sum((pred & label) * weight, dim=2)
-            # (B, T)
-            intersection_ic = (pred_binary * labels_unsqueezed * ic_weights.view(1, 1, -1)).sum(dim=2)
+            # intersection_ic (TP) shape: (B, T)
+            intersection_ic = (pred_binary * labels_unsqueezed * ic_weights_unsqueezed).sum(dim=2)
             
-            # Union (Prediction) IC: sum(pred * weight, dim=2)
-            # (B, T)
-            pred_ic = (pred_binary * ic_weights.view(1, 1, -1)).sum(dim=2)
+            # pred_ic (TP + FP) shape: (B, T)
+            pred_ic = (pred_binary * ic_weights_unsqueezed).sum(dim=2)
             
-            # Precision: Int / Pred
+            # Precision: TP / Pred
             precision = intersection_ic / (pred_ic + 1e-9)
             
-            # Recall: Int / True
+            # Recall: TP / True
             recall = intersection_ic / (true_ic.view(-1, 1) + 1e-9)
             
-            # Accumulate
+            # RU (False Negative): (True - TP) -> (B, T)
+            ru = true_ic.view(-1, 1) - intersection_ic
+            # Handle potential slight float errors
+            ru = torch.clamp(ru, min=0.0)
+            
+            # MI (False Positive): (Pred - TP) -> (B, T)
+            mi = pred_ic - intersection_ic 
+            mi = torch.clamp(mi, min=0.0)
+            
+            # Accumulate Sums
             sum_prec += precision.sum(dim=0)
             sum_rec += recall.sum(dim=0)
+            sum_ru += ru.sum(dim=0)
+            sum_mi += mi.sum(dim=0)
             
             total_samples += input_ids.size(0)
             
-            # Explicit GC to be safe
-            del logits, probs, pred_binary, intersection_ic, pred_ic
+            # GC
+            del logits, probs, pred_binary, intersection_ic, pred_ic, ru, mi
             
+            # Dry run break
+            if hasattr(dataloader.dataset, 'dry_run') and dataloader.dataset.dry_run:
+                 # Dataset doesn't hold flag, we need to pass it or check total_samples
+                 pass
+            if total_samples > 200 and 'dry_run' in str(type(dataloader.dataset)): # hacky check?
+                pass 
+                
     if f_pred:
         f_pred.close()
         print(f"Saved predictions to {pred_output_path}")
@@ -263,14 +256,28 @@ def evaluate_gpu(model, dataloader, ic_weights, device, thresholds=None, pred_ou
     # Compute Averages
     avg_prec = sum_prec / total_samples
     avg_rec = sum_rec / total_samples
+    avg_ru = sum_ru / total_samples
+    avg_mi = sum_mi / total_samples
     
-    # F1
+    # F-max
     f1_scores = 2 * avg_prec * avg_rec / (avg_prec + avg_rec + 1e-9)
-    
     best_fmax = f1_scores.max().item()
     best_t_idx = f1_scores.argmax().item()
-    best_threshold = thresholds[best_t_idx].item()
-    
+    best_threshold_f = thresholds[best_t_idx].item()
+    
+    # S-min
+    # S = sqrt(RU^2 + MI^2)
+    s_scores = torch.sqrt(avg_ru**2 + avg_mi**2)
+    min_s = s_scores.min().item()
+    best_s_idx = s_scores.argmin().item()
+    best_threshold_s = thresholds[best_s_idx].item()
+    
+    metrics = {
+        'fmax_w': best_fmax,
+        'threshold_fmax': best_threshold_f,
+        'smin': min_s,
+        'threshold_smin': best_threshold_s,
+    }
     
     # Save Metrics Detail
     if metrics_output_path:
@@ -278,12 +285,15 @@ def evaluate_gpu(model, dataloader, ic_weights, device, thresholds=None, pred_ou
             'threshold': thresholds.cpu().numpy(),
             'precision': avg_prec.cpu().numpy(),
             'recall': avg_rec.cpu().numpy(),
-            'f1': f1_scores.cpu().numpy()
+            'f1': f1_scores.cpu().numpy(),
+            'ru': avg_ru.cpu().numpy(),
+            'mi': avg_mi.cpu().numpy(),
+            's': s_scores.cpu().numpy()
         }
         pd.DataFrame(metrics_data).to_csv(metrics_output_path, sep='\t', index=False)
         print(f"Saved detailed metrics to {metrics_output_path}")
 
-    return best_fmax, best_threshold, f1_scores.cpu().numpy()
+    return metrics
 
 def validate_loss(model, valid_loader, criterion, device):
     model.eval()
@@ -545,19 +555,17 @@ def main():
             mlflow.log_metric("best_val_loss", best_val_loss, step=epoch)
         
         # Custom Evaluation Schedule: 3, 10, 15, 20
-        # For dryrun, maybe run on epoch 1 too?
-        if epoch in [1, 3, 10, 15, 20]:
-            print(f"Epoch {epoch}: Running CAFA Evaluation on Best Model (Loss: {best_val_loss:.4f})...")
+        # For dryrun, evaluate on epoch 1 too, and force a break in loops
+        run_eval = epoch in [1, 3, 10, 15, 20] or args.dry_run
+        
+        if run_eval:
+            print(f"Epoch {epoch}: Running GPU CAFA Evaluation on Best Model (Loss: {best_val_loss:.4f})...")
             
-            # Save current state to restore after eval
             current_state = {
                 'model': model.state_dict(),
                 'optimizer': optimizer.state_dict() 
             }
             
-            # Load best model for evaluation
-            # If doing dry run, we might not have a best model yet if epoch 1 val loss wasn't best? 
-            # Actually line 491 guarantees best_val_loss update on first epoch.
             if os.path.exists(best_model_path):
                 checkpoint = torch.load(best_model_path)
                 model.load_state_dict(checkpoint['model_state_dict'])
@@ -565,11 +573,19 @@ def main():
             else:
                 print("Warning: Best model not found, evaluating current model.")
 
-            # Run Evaluation: Novel
-            metrics_novel = run_evaluation(model, val_novel_loader, ontologies, gt_novel, device, args.output_dir, epoch, prefix="novel")
-            
-            # Run Evaluation: Homolog
-            metrics_homolog = run_evaluation(model, val_homolog_loader, ontologies, gt_homolog, device, args.output_dir, epoch, prefix="homolog")
+            # Run Evaluation: Novel (GPU)
+            metrics_novel = evaluate_gpu(
+                model, val_novel_loader, ic_weights, device, 
+                pred_output_path=output_dir / f"gpu_preds_novel_epoch_{epoch}.tsv",
+                metrics_output_path=output_dir / f"metrics_novel_epoch_{epoch}.tsv"
+            )
+            
+            # Run Evaluation: Homolog (GPU)
+            metrics_homolog = evaluate_gpu(
+                model, val_homolog_loader, ic_weights, device,
+                pred_output_path=output_dir / f"gpu_preds_homolog_epoch_{epoch}.tsv",
+                metrics_output_path=output_dir / f"metrics_homolog_epoch_{epoch}.tsv"
+            )
             
             # Log Metrics
             all_metrics = {}
@@ -581,10 +597,35 @@ def main():
             mlflow.log_metrics(all_metrics, step=epoch)
             print("Evaluation Complete. Metrics:", all_metrics)
             
+            # Save Best F-max Model (Novel as primary?)
+            # Usually we care about Novel Genus F-max
+            novel_fmax = metrics_novel['fmax_w']
+            if novel_fmax > best_wf_max:
+                best_wf_max = novel_fmax
+                print(f"New Best Novel F-max: {best_wf_max:.4f}")
+                save_checkpoint(model, optimizer, epoch, {'val_loss': best_val_loss, 'novel_fmax': best_wf_max}, output_dir / "best_model_fmax.pth")
+            
             # Restore training state
             model.load_state_dict(current_state['model'])
             optimizer.load_state_dict(current_state['optimizer'])
             print("Restored training state.")
+            
+            if args.dry_run:
+                print("Dry run complete (Evaluation).")
+            # Usually we care about Novel Genus F-max
+            novel_fmax = metrics_novel['fmax_w']
+            if novel_fmax > best_wf_max:
+                best_wf_max = novel_fmax
+                print(f"New Best Novel F-max: {best_wf_max:.4f}")
+                save_checkpoint(model, optimizer, epoch, {'val_loss': best_val_loss, 'novel_fmax': best_wf_max}, output_dir / "best_model_fmax.pth")
+            
+            # Restore training state
+            model.load_state_dict(current_state['model'])
+            optimizer.load_state_dict(current_state['optimizer'])
+            print("Restored training state.")
+            
+            if args.dry_run:
+                print("Dry run complete (Evaluation).")
 
         save_checkpoint(model, optimizer, epoch, {'val_loss': val_loss}, output_dir / "latest_model.pth")