try again on gradio progress update streaming

app.py

@@ -108,7 +108,7 @@ def run_full_evaluation_gradio():
         for update in evaluate(model, test_dataloader_full, device):
             if isinstance(update, dict):
                 # This is the final results dictionary
-                results_str = "--- Full Evaluation Results ---\n"
+                results_str = "\n--- Full Evaluation Results ---\n" # Start with a newline
                 for key, value in update.items():
                     if isinstance(value, float):
                         results_str += f"{key.capitalize()}: {value:.4f}\n"
@@ -120,7 +120,7 @@ def run_full_evaluation_gradio():
                 break # Stop after getting the results dict
             else:
                 # This is a progress string
-                yield update
+                yield str(update) + "\n" # Append newline to each progress string
         
         # Ensure the final formatted results string is yielded if not already (e.g., if loop broke early)
         # However, the logic above should yield it before breaking.

evaluation.py

@@ -13,8 +13,6 @@ def evaluate(model, dataloader, device):
     num_batches = len(dataloader)
     processed_batches = 0
 
-    yield "Starting evaluation..."
-
     with torch.no_grad():
         for batch in dataloader: # dataloader here should not be pre-wrapped with tqdm by the caller if we yield progress
             processed_batches += 1
@@ -54,8 +52,19 @@ def evaluate(model, dataloader, device):
             all_preds.extend(preds.cpu().numpy())
             
             all_labels.extend(labels.cpu().numpy()) 
+
+            # Populate probabilities for AUC calculation
+            if logits.shape[1] > 1: 
+                # Multi-class or multi-label, assuming positive class is at index 1 for binary-like AUC
+                probs_for_auc = torch.softmax(logits, dim=1)[:, 1] 
+            else: 
+                # Binary classification with a single logit output
+                probs_for_auc = torch.sigmoid(logits).squeeze() 
+            all_probs_for_auc.extend(probs_for_auc.cpu().numpy())
+
             # Yield progress update
-            if processed_batches % (num_batches // 20) == 0 or processed_batches == num_batches: # Update roughly 20 times + final
+            progress_update_frequency = max(1, num_batches // 20) # Ensure at least 1 to avoid modulo zero
+            if processed_batches % progress_update_frequency == 0 or processed_batches == num_batches: # Update roughly 20 times + final
                 yield f"Processed {processed_batches}/{num_batches} batches ({processed_batches/num_batches*100:.2f}%)"
             
     avg_loss = total_loss / num_batches