Update utils/metrics.py

utils/metrics.py

@@ -119,4 +119,96 @@ class GraphMetrics:
         except Exception as e:
             print(f"Evaluation error: {e}")
             metrics = {
-                'accuracy': 0.0
+                'accuracy': 0.0
+            'f1_macro': 0.0,
+               'f1_micro': 0.0,
+               'loss': float('inf'),
+               'error': str(e)
+           }
+               
+       return metrics
+   
+   @staticmethod
+   def evaluate_graph_classification(model, dataloader, device, detailed=False):
+       """Comprehensive graph classification evaluation"""
+       model.eval()
+       
+       all_preds = []
+       all_targets = []
+       total_loss = 0.0
+       num_batches = 0
+       
+       try:
+           criterion = torch.nn.CrossEntropyLoss()
+           
+           with torch.no_grad():
+               for batch in dataloader:
+                   batch = batch.to(device)
+                   h = model(batch.x, batch.edge_index, batch.batch)
+                   
+                   # Graph-level prediction
+                   graph_h = model.get_graph_embedding(h, batch.batch)
+                   
+                   if hasattr(model, 'classifier') and model.classifier is not None:
+                       pred = model.classifier(graph_h)
+                   else:
+                       # Initialize classifier
+                       num_classes = len(torch.unique(batch.y))
+                       model._init_classifier(num_classes, device)
+                       pred = model.classifier(graph_h)
+                   
+                   all_preds.append(pred.cpu())
+                   all_targets.append(batch.y.cpu())
+                   
+                   # Calculate loss
+                   loss = criterion(pred, batch.y)
+                   total_loss += loss.item()
+                   num_batches += 1
+           
+           if all_preds:
+               all_preds = torch.cat(all_preds, dim=0)
+               all_targets = torch.cat(all_targets, dim=0)
+               
+               metrics = {
+                   'accuracy': GraphMetrics.accuracy(all_preds, all_targets),
+                   'f1_macro': GraphMetrics.f1_score_macro(all_preds, all_targets),
+                   'f1_micro': GraphMetrics.f1_score_micro(all_preds, all_targets),
+                   'loss': total_loss / max(num_batches, 1)
+               }
+               
+               if detailed:
+                   metrics['roc_auc'] = GraphMetrics.roc_auc(all_preds, all_targets)
+                   metrics['classification_report'] = GraphMetrics.classification_report_dict(all_preds, all_targets)
+           else:
+               metrics = {'error': 'No predictions generated'}
+               
+       except Exception as e:
+           print(f"Graph classification evaluation error: {e}")
+           metrics = {
+               'accuracy': 0.0,
+               'f1_macro': 0.0,
+               'f1_micro': 0.0,
+               'loss': float('inf'),
+               'error': str(e)
+           }
+       
+       return metrics
+   
+   @staticmethod
+   def compare_models(results_dict):
+       """Compare multiple model results"""
+       comparison = {}
+       
+       for model_name, metrics in results_dict.items():
+           comparison[model_name] = {
+               'accuracy': metrics.get('accuracy', 0.0),
+               'f1_macro': metrics.get('f1_macro', 0.0),
+               'f1_micro': metrics.get('f1_micro', 0.0),
+               'loss': metrics.get('loss', float('inf'))
+           }
+       
+       # Find best performing model
+       best_model = max(comparison.keys(), key=lambda k: comparison[k]['accuracy'])
+       comparison['best_model'] = best_model
+       
+       return comparison