Update utils/metrics.py

utils/metrics.py

@@ -119,96 +119,96 @@ class GraphMetrics:
         except Exception as e:
             print(f"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 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
+                '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