Download backend/src/evaluate.py from StillWorking/Brain-Tumor-AI: direct link, hf CLI and curl.
- Browser
- Download file 26.4 kB
-
https://huggingface.co/datasets/StillWorking/Brain-Tumor-AI/resolve/main/backend/src/evaluate.py
- Command line
-
hf download hf://datasets/StillWorking/Brain-Tumor-AI/backend/src/evaluate.py
-
curl -L -o evaluate.py https://huggingface.co/datasets/StillWorking/Brain-Tumor-AI/resolve/main/backend/src/evaluate.py
26.4 kB
| """ | |
| Evaluation Script - Stage 7 | |
| Comprehensive model evaluation with metrics, visualizations, and error analysis. | |
| Hardware: RTX 3050 6GB, CUDA-only evaluation | |
| Metrics: Accuracy, per-class precision/recall/F1, macro-recall, ROC-AUC, confusion matrix | |
| """ | |
| import argparse | |
| import json | |
| import sys | |
| import time | |
| from glob import glob | |
| from pathlib import Path | |
| from typing import Dict, List, Tuple | |
| import matplotlib.pyplot as plt | |
| import numpy as np | |
| import pandas as pd | |
| import seaborn as sns | |
| import torch | |
| import torch.nn as nn | |
| from sklearn.metrics import ( | |
| accuracy_score, | |
| confusion_matrix, | |
| precision_recall_fscore_support, | |
| roc_auc_score, | |
| roc_curve, | |
| ) | |
| from torch.cuda.amp import autocast | |
| from torch.utils.data import DataLoader | |
| from tqdm import tqdm | |
| # Add src to path | |
| sys.path.insert(0, str(Path(__file__).parent)) | |
| from data.dataset import BrainTumorDataset, CLASS_TO_IDX, IDX_TO_CLASS | |
| from data.transforms import get_val_transforms | |
| from models import create_model, get_model_info | |
| from utils import load_config, set_seed | |
| def parse_args() -> argparse.Namespace: | |
| """Parse command line arguments.""" | |
| parser = argparse.ArgumentParser( | |
| description="Evaluate brain tumor classifier with comprehensive metrics" | |
| ) | |
| parser.add_argument( | |
| "--checkpoint", | |
| type=str, | |
| required=True, | |
| help="Path to checkpoint file (.pth) or glob pattern for multiple checkpoints" | |
| ) | |
| parser.add_argument( | |
| "--config", | |
| type=str, | |
| required=True, | |
| help="Path to YAML config file (e.g., configs/efficientnet_b0.yaml)" | |
| ) | |
| parser.add_argument( | |
| "--split", | |
| type=str, | |
| default="test", | |
| choices=["train", "val", "test"], | |
| help="Data split to evaluate on (default: test)" | |
| ) | |
| parser.add_argument( | |
| "--device", | |
| type=str, | |
| default="auto", | |
| choices=["auto", "cuda", "cpu"], | |
| help="Inference device (default: auto — CUDA if available)", | |
| ) | |
| parser.add_argument( | |
| "--exclude-leaked", | |
| action="store_true", | |
| help=( | |
| "Drop evaluated samples whose content also appears in another " | |
| "split (honest, leakage-free metrics)" | |
| ), | |
| ) | |
| return parser.parse_args() | |
| def resolve_device(requested: str) -> str: | |
| """Resolve 'auto' to CUDA when available, otherwise CPU.""" | |
| if requested == "auto": | |
| return "cuda" if torch.cuda.is_available() else "cpu" | |
| if requested == "cuda" and not torch.cuda.is_available(): | |
| raise RuntimeError("CUDA requested but not available") | |
| return requested | |
| def setup_evaluation(config: dict, requested_device: str = "auto") -> Tuple[str, Path, Path]: | |
| """ | |
| Setup evaluation environment: device, seeds, directories. | |
| Args: | |
| config: Configuration dictionary | |
| requested_device: 'auto', 'cuda' or 'cpu' | |
| Returns: | |
| Tuple of (device, processed_dir, reports_dir) | |
| """ | |
| device = resolve_device(requested_device) | |
| print("=" * 70) | |
| print("Brain Tumor MRI Classifier - Model Evaluation") | |
| print("=" * 70) | |
| if device == "cuda": | |
| print(f"GPU: {torch.cuda.get_device_name(0)}") | |
| print(f"CUDA Version: {torch.version.cuda}") | |
| else: | |
| print("Device: CPU (CUDA not used)") | |
| print(f"PyTorch Version: {torch.__version__}") | |
| print() | |
| # Set seeds for reproducibility | |
| seed = config.get('seed', 42) | |
| set_seed(seed) | |
| # Get directories | |
| workspace_root = Path.cwd() | |
| processed_dir = workspace_root / config['data']['processed_dir'] | |
| reports_dir = workspace_root / "reports" | |
| reports_dir.mkdir(parents=True, exist_ok=True) | |
| print(f"Data directory: {processed_dir}") | |
| print(f"Reports directory: {reports_dir}") | |
| print() | |
| return device, processed_dir, reports_dir | |
| def load_dataloader( | |
| config: dict, | |
| processed_dir: Path, | |
| split: str | |
| ) -> Tuple[DataLoader, pd.DataFrame]: | |
| """ | |
| Create dataloader for evaluation. | |
| Args: | |
| config: Configuration dictionary | |
| processed_dir: Directory with processed data | |
| split: Data split to load (train/val/test) | |
| Returns: | |
| Tuple of (dataloader, manifest_df) | |
| """ | |
| print("=" * 70) | |
| print(f"Loading Data (split: {split})") | |
| print("=" * 70) | |
| # Load manifest | |
| manifest_path = processed_dir / "manifest.csv" | |
| print(f"Loading manifest: {manifest_path}") | |
| manifest = pd.read_csv(manifest_path) | |
| # Filter for specified split | |
| split_df = manifest[manifest['split'] == split].copy() | |
| if len(split_df) == 0: | |
| raise ValueError(f"No samples found for split '{split}' in manifest") | |
| print(f"Total samples in {split}: {len(split_df)}") | |
| # Class distribution | |
| print(f"\nClass distribution:") | |
| class_counts = split_df['class'].value_counts() | |
| for class_name, count in class_counts.items(): | |
| print(f" {class_name:12s}: {count:4d} ({count/len(split_df)*100:.1f}%)") | |
| print() | |
| # Create dataset with validation transforms (no augmentation) | |
| val_transform = get_val_transforms() | |
| dataset = BrainTumorDataset( | |
| data_dir=processed_dir, | |
| manifest_df=split_df, | |
| transform=val_transform | |
| ) | |
| # DataLoader with larger batch size for evaluation | |
| batch_size = config.get('evaluation', {}).get('batch_size', 128) | |
| num_workers = config['dataloader']['num_workers'] | |
| pin_memory = config['dataloader']['pin_memory'] | |
| dataloader = DataLoader( | |
| dataset, | |
| batch_size=batch_size, | |
| shuffle=False, | |
| num_workers=num_workers, | |
| pin_memory=pin_memory, | |
| persistent_workers=num_workers > 0 | |
| ) | |
| print(f"Batch size: {batch_size}") | |
| print(f"Number of batches: {len(dataloader)}") | |
| print() | |
| return dataloader, split_df | |
| def load_model_and_checkpoint( | |
| config: dict, | |
| checkpoint_path: str, | |
| device: str | |
| ) -> Tuple[nn.Module, Dict]: | |
| """ | |
| Load model architecture and checkpoint weights. | |
| Args: | |
| config: Configuration dictionary | |
| checkpoint_path: Path to checkpoint file | |
| device: Device to load model on | |
| Returns: | |
| Tuple of (model, checkpoint_data) | |
| """ | |
| print("=" * 70) | |
| print("Loading Model") | |
| print("=" * 70) | |
| print(f"Checkpoint: {checkpoint_path}") | |
| # Load checkpoint | |
| # weights_only=False: our own checkpoints contain numpy arrays in `metrics`. | |
| checkpoint = torch.load(checkpoint_path, map_location=device, weights_only=False) | |
| # Get config from checkpoint if available, otherwise use provided config | |
| model_config = checkpoint.get('config', config) | |
| # Create model | |
| model = create_model(model_config) | |
| # Load state dict | |
| model.load_state_dict(checkpoint['model_state_dict']) | |
| # Model info | |
| info = get_model_info(model) | |
| print(f"Model: {model_config['model']['name']}") | |
| print(f"Parameters: {info['total_params']:,}") | |
| print(f"Model size: {info['model_size_mb']:.2f} MB") | |
| if 'epoch' in checkpoint: | |
| print(f"Checkpoint epoch: {checkpoint['epoch']}") | |
| if 'metrics' in checkpoint: | |
| val_metrics = checkpoint['metrics'] | |
| if 'macro_recall' in val_metrics: | |
| print(f"Validation macro recall: {val_metrics['macro_recall']:.4f}") | |
| print() | |
| # Set to eval mode | |
| model.eval() | |
| # Convert to channels_last if needed | |
| if model_config['training'].get('channels_last', False): | |
| model = model.to(memory_format=torch.channels_last) | |
| print("Memory format: channels_last") | |
| # Move to GPU | |
| model = model.to(device) | |
| print() | |
| return model, checkpoint | |
| def run_inference( | |
| model: nn.Module, | |
| dataloader: DataLoader, | |
| manifest_df: pd.DataFrame, | |
| device: str, | |
| config: dict | |
| ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, List[str]]: | |
| """ | |
| Run inference on dataset and collect predictions. | |
| Args: | |
| model: Model to evaluate | |
| dataloader: Data loader | |
| manifest_df: Manifest DataFrame with file paths | |
| device: Device to run on | |
| config: Configuration dictionary | |
| Returns: | |
| Tuple of (predictions, probabilities, ground_truth, file_paths) | |
| """ | |
| print("=" * 70) | |
| print("Running Inference") | |
| print("=" * 70) | |
| all_predictions = [] | |
| all_probabilities = [] | |
| all_labels = [] | |
| channels_last = config['training'].get('channels_last', False) | |
| use_amp = config['training']['use_amp'] | |
| amp_dtype = torch.float16 if config['training']['amp_dtype'] == 'float16' else torch.bfloat16 | |
| # Progress bar | |
| pbar = tqdm(dataloader, desc="Evaluating", total=len(dataloader)) | |
| for images, labels in pbar: | |
| # Move to device | |
| images = images.to(device, non_blocking=True) | |
| # Convert to channels_last if configured | |
| if channels_last: | |
| images = images.to(memory_format=torch.channels_last) | |
| # Mixed precision forward pass | |
| with autocast(enabled=use_amp, dtype=amp_dtype): | |
| outputs = model(images) | |
| # Get predictions and probabilities | |
| probabilities = torch.softmax(outputs, dim=1) | |
| predictions = outputs.argmax(dim=1) | |
| # Collect results | |
| all_predictions.extend(predictions.cpu().numpy()) | |
| all_probabilities.extend(probabilities.cpu().numpy()) | |
| all_labels.extend(labels.numpy()) | |
| # Convert to arrays | |
| y_pred = np.array(all_predictions) | |
| y_proba = np.array(all_probabilities) | |
| y_true = np.array(all_labels) | |
| # Get file paths from manifest | |
| file_paths = manifest_df['filepath'].tolist() | |
| # Log memory usage | |
| max_memory_mb = torch.cuda.max_memory_allocated() / (1024 ** 2) | |
| print(f"\nGPU max memory used: {max_memory_mb:.2f} MB") | |
| print() | |
| return y_pred, y_proba, y_true, file_paths | |
| def compute_comprehensive_metrics( | |
| y_true: np.ndarray, | |
| y_pred: np.ndarray, | |
| y_proba: np.ndarray, | |
| class_names: List[str] | |
| ) -> Dict: | |
| """ | |
| Compute comprehensive classification metrics. | |
| Args: | |
| y_true: Ground truth labels | |
| y_pred: Predicted labels | |
| y_proba: Prediction probabilities | |
| class_names: List of class names | |
| Returns: | |
| Dictionary with all metrics | |
| """ | |
| print("=" * 70) | |
| print("Computing Metrics") | |
| print("=" * 70) | |
| # Overall accuracy | |
| accuracy = accuracy_score(y_true, y_pred) | |
| # Per-class precision, recall, F1 | |
| precision, recall, f1, support = precision_recall_fscore_support( | |
| y_true, y_pred, average=None, zero_division=0 | |
| ) | |
| # Macro-averaged recall (primary metric for medical imaging) | |
| macro_recall = recall.mean() | |
| # Confusion matrix | |
| cm = confusion_matrix(y_true, y_pred) | |
| # ROC-AUC for each class (one-vs-rest) | |
| roc_auc = {} | |
| roc_curves = {} | |
| try: | |
| for i, class_name in enumerate(class_names): | |
| # One-vs-rest binary labels | |
| y_true_binary = (y_true == i).astype(int) | |
| y_proba_class = y_proba[:, i] | |
| # Compute ROC-AUC | |
| auc = roc_auc_score(y_true_binary, y_proba_class) | |
| roc_auc[class_name] = float(auc) | |
| # Compute ROC curve for plotting | |
| fpr, tpr, thresholds = roc_curve(y_true_binary, y_proba_class) | |
| roc_curves[class_name] = { | |
| 'fpr': fpr.tolist(), | |
| 'tpr': tpr.tolist(), | |
| 'thresholds': thresholds.tolist() | |
| } | |
| except Exception as e: | |
| print(f"Warning: Could not compute ROC-AUC: {e}") | |
| roc_auc = {name: 0.0 for name in class_names} | |
| roc_curves = {} | |
| # Build per-class metrics | |
| per_class_metrics = {} | |
| for i, class_name in enumerate(class_names): | |
| per_class_metrics[class_name] = { | |
| 'precision': float(precision[i]), | |
| 'recall': float(recall[i]), | |
| 'f1': float(f1[i]), | |
| 'support': int(support[i]), | |
| 'roc_auc': roc_auc.get(class_name, 0.0) | |
| } | |
| metrics = { | |
| 'accuracy': float(accuracy), | |
| 'macro_recall': float(macro_recall), | |
| 'per_class': per_class_metrics, | |
| 'confusion_matrix': cm.tolist(), | |
| 'roc_curves': roc_curves | |
| } | |
| print(f"Overall Accuracy: {accuracy*100:.2f}%") | |
| print(f"Macro Recall: {macro_recall*100:.2f}%") | |
| print() | |
| return metrics | |
| def print_metrics_table(metrics: Dict): | |
| """ | |
| Print metrics in a nicely formatted table. | |
| Args: | |
| metrics: Dictionary with computed metrics | |
| """ | |
| print("=" * 70) | |
| print("Detailed Metrics") | |
| print("=" * 70) | |
| print() | |
| # Create DataFrame for better formatting | |
| rows = [] | |
| for class_name, class_metrics in metrics['per_class'].items(): | |
| rows.append({ | |
| 'Class': class_name, | |
| 'Precision': f"{class_metrics['precision']:.3f}", | |
| 'Recall': f"{class_metrics['recall']:.3f}", | |
| 'F1-Score': f"{class_metrics['f1']:.3f}", | |
| 'ROC-AUC': f"{class_metrics['roc_auc']:.3f}", | |
| 'Support': class_metrics['support'] | |
| }) | |
| df = pd.DataFrame(rows) | |
| print(df.to_string(index=False)) | |
| print() | |
| print(f"Overall Accuracy: {metrics['accuracy']:.3f}") | |
| print(f"Macro Recall: {metrics['macro_recall']:.3f}") | |
| print() | |
| def plot_confusion_matrix( | |
| confusion_matrix: np.ndarray, | |
| class_names: List[str], | |
| split: str, | |
| model_name: str, | |
| save_path: Path | |
| ): | |
| """ | |
| Plot and save confusion matrix heatmap. | |
| Args: | |
| confusion_matrix: Confusion matrix array | |
| class_names: List of class names | |
| split: Data split name | |
| model_name: Model name for title | |
| save_path: Path to save figure | |
| """ | |
| plt.figure(figsize=(10, 8)) | |
| # Convert to numpy array if needed | |
| if isinstance(confusion_matrix, list): | |
| confusion_matrix = np.array(confusion_matrix) | |
| # Normalize confusion matrix to percentages | |
| cm_normalized = confusion_matrix.astype('float') / confusion_matrix.sum(axis=1)[:, np.newaxis] * 100 | |
| # Create heatmap | |
| sns.heatmap( | |
| cm_normalized, | |
| annot=True, | |
| fmt='.1f', | |
| cmap='Blues', | |
| xticklabels=class_names, | |
| yticklabels=class_names, | |
| cbar_kws={'label': 'Percentage (%)'} | |
| ) | |
| plt.title(f'Confusion Matrix - {model_name} ({split} set)', fontsize=14, fontweight='bold') | |
| plt.ylabel('True Label', fontsize=12) | |
| plt.xlabel('Predicted Label', fontsize=12) | |
| plt.xticks(rotation=45, ha='right') | |
| plt.yticks(rotation=0) | |
| plt.tight_layout() | |
| # Save figure | |
| plt.savefig(save_path, dpi=300, bbox_inches='tight') | |
| plt.close() | |
| print(f"Saved confusion matrix: {save_path}") | |
| def plot_roc_curves( | |
| roc_curves: Dict, | |
| class_names: List[str], | |
| metrics: Dict, | |
| split: str, | |
| model_name: str, | |
| save_path: Path | |
| ): | |
| """ | |
| Plot and save ROC curves for all classes. | |
| Args: | |
| roc_curves: Dictionary with ROC curve data for each class | |
| class_names: List of class names | |
| metrics: Metrics dictionary with ROC-AUC scores | |
| split: Data split name | |
| model_name: Model name for title | |
| save_path: Path to save figure | |
| """ | |
| if not roc_curves: | |
| print("Warning: No ROC curves to plot") | |
| return | |
| plt.figure(figsize=(10, 8)) | |
| # Plot ROC curve for each class | |
| colors = ['blue', 'red', 'green', 'orange'] | |
| for i, class_name in enumerate(class_names): | |
| if class_name not in roc_curves: | |
| continue | |
| curve_data = roc_curves[class_name] | |
| fpr = np.array(curve_data['fpr']) | |
| tpr = np.array(curve_data['tpr']) | |
| auc = metrics['per_class'][class_name]['roc_auc'] | |
| plt.plot( | |
| fpr, tpr, | |
| color=colors[i % len(colors)], | |
| lw=2, | |
| label=f'{class_name} (AUC = {auc:.3f})' | |
| ) | |
| # Plot diagonal reference line | |
| plt.plot([0, 1], [0, 1], 'k--', lw=2, label='Random Classifier') | |
| plt.xlim([0.0, 1.0]) | |
| plt.ylim([0.0, 1.05]) | |
| plt.xlabel('False Positive Rate', fontsize=12) | |
| plt.ylabel('True Positive Rate', fontsize=12) | |
| plt.title(f'ROC Curves - {model_name} ({split} set)', fontsize=14, fontweight='bold') | |
| plt.legend(loc='lower right', fontsize=10) | |
| plt.grid(alpha=0.3) | |
| plt.tight_layout() | |
| # Save figure | |
| plt.savefig(save_path, dpi=300, bbox_inches='tight') | |
| plt.close() | |
| print(f"Saved ROC curves: {save_path}") | |
| def analyze_misclassifications( | |
| y_true: np.ndarray, | |
| y_pred: np.ndarray, | |
| y_proba: np.ndarray, | |
| file_paths: List[str], | |
| class_names: List[str], | |
| split: str, | |
| model_name: str, | |
| save_path: Path | |
| ) -> pd.DataFrame: | |
| """ | |
| Analyze and save misclassifications. | |
| Args: | |
| y_true: Ground truth labels | |
| y_pred: Predicted labels | |
| y_proba: Prediction probabilities | |
| file_paths: List of file paths | |
| class_names: List of class names | |
| split: Data split name | |
| model_name: Model name | |
| save_path: Path to save CSV | |
| Returns: | |
| DataFrame with misclassifications | |
| """ | |
| # Find misclassified samples | |
| misclassified_mask = y_true != y_pred | |
| misclassified_indices = np.where(misclassified_mask)[0] | |
| if len(misclassified_indices) == 0: | |
| print("No misclassifications found!") | |
| return pd.DataFrame() | |
| # Build DataFrame | |
| rows = [] | |
| for idx in misclassified_indices: | |
| true_label = int(y_true[idx]) | |
| pred_label = int(y_pred[idx]) | |
| confidence = float(y_proba[idx, pred_label]) | |
| rows.append({ | |
| 'filepath': file_paths[idx], | |
| 'true_class': class_names[true_label], | |
| 'predicted_class': class_names[pred_label], | |
| 'confidence': confidence, | |
| 'true_label': true_label, | |
| 'predicted_label': pred_label | |
| }) | |
| df = pd.DataFrame(rows) | |
| # Sort by confidence (highest confidence errors first) | |
| df = df.sort_values('confidence', ascending=False) | |
| # Save to CSV | |
| df.to_csv(save_path, index=False) | |
| print(f"\nMisclassification Analysis:") | |
| print(f" Total misclassifications: {len(df)}") | |
| print(f" Misclassification rate: {len(df)/len(y_true)*100:.2f}%") | |
| print(f"\n Sample misclassifications (highest confidence errors):") | |
| # Show top 5 high-confidence errors | |
| for i, row in df.head(5).iterrows(): | |
| print(f" {row['filepath']}") | |
| print(f" True: {row['true_class']}, Predicted: {row['predicted_class']} " | |
| f"(confidence: {row['confidence']:.3f})") | |
| print(f"\nSaved misclassifications: {save_path}") | |
| return df | |
| def identify_worst_class(metrics: Dict) -> Tuple[str, float]: | |
| """ | |
| Identify the worst-performing class by recall. | |
| Args: | |
| metrics: Metrics dictionary | |
| Returns: | |
| Tuple of (class_name, recall) | |
| """ | |
| worst_class = None | |
| worst_recall = 1.0 | |
| for class_name, class_metrics in metrics['per_class'].items(): | |
| recall = class_metrics['recall'] | |
| if recall < worst_recall: | |
| worst_recall = recall | |
| worst_class = class_name | |
| return worst_class, worst_recall | |
| def save_metrics_json( | |
| metrics: Dict, | |
| split: str, | |
| model_name: str, | |
| save_path: Path | |
| ): | |
| """ | |
| Save detailed metrics to JSON file. | |
| Args: | |
| metrics: Metrics dictionary | |
| split: Data split name | |
| model_name: Model name | |
| save_path: Path to save JSON | |
| """ | |
| # Add metadata | |
| output = { | |
| 'model': model_name, | |
| 'split': split, | |
| 'timestamp': time.strftime('%Y-%m-%d %H:%M:%S'), | |
| 'metrics': metrics | |
| } | |
| with open(save_path, 'w') as f: | |
| json.dump(output, f, indent=2) | |
| print(f"Saved detailed metrics: {save_path}") | |
| def evaluate_single_checkpoint( | |
| checkpoint_path: str, | |
| config: dict, | |
| split: str, | |
| device: str, | |
| processed_dir: Path, | |
| reports_dir: Path | |
| ) -> Dict: | |
| """ | |
| Evaluate a single checkpoint. | |
| Args: | |
| checkpoint_path: Path to checkpoint file | |
| config: Configuration dictionary | |
| split: Data split to evaluate on | |
| device: Device to run on | |
| processed_dir: Directory with processed data | |
| reports_dir: Directory to save reports | |
| Returns: | |
| Dictionary with evaluation results | |
| """ | |
| # Load data | |
| dataloader, manifest_df = load_dataloader(config, processed_dir, split) | |
| # Load model | |
| model, checkpoint = load_model_and_checkpoint(config, checkpoint_path, device) | |
| # Get model name for file naming | |
| model_name = config['model']['name'] | |
| checkpoint_name = Path(checkpoint_path).stem | |
| # Run inference | |
| y_pred, y_proba, y_true, file_paths = run_inference( | |
| model, dataloader, manifest_df, device, config | |
| ) | |
| # Compute metrics | |
| class_names = config['data']['classes'] | |
| metrics = compute_comprehensive_metrics(y_true, y_pred, y_proba, class_names) | |
| # Print metrics table | |
| print_metrics_table(metrics) | |
| # Identify worst-performing class | |
| worst_class, worst_recall = identify_worst_class(metrics) | |
| print(f"Worst-performing class: {worst_class} (recall: {worst_recall:.3f})") | |
| print() | |
| # Save visualizations | |
| print("=" * 70) | |
| print("Saving Visualizations") | |
| print("=" * 70) | |
| # Confusion matrix | |
| cm_path = reports_dir / f"confusion_matrix_{split}_{checkpoint_name}.png" | |
| plot_confusion_matrix( | |
| np.array(metrics['confusion_matrix']), | |
| class_names, | |
| split, | |
| model_name, | |
| cm_path | |
| ) | |
| # ROC curves | |
| roc_path = reports_dir / f"roc_curves_{split}_{checkpoint_name}.png" | |
| plot_roc_curves( | |
| metrics['roc_curves'], | |
| class_names, | |
| metrics, | |
| split, | |
| model_name, | |
| roc_path | |
| ) | |
| # Misclassifications | |
| misclass_path = reports_dir / f"misclassifications_{split}_{checkpoint_name}.csv" | |
| misclass_df = analyze_misclassifications( | |
| y_true, y_pred, y_proba, file_paths, class_names, split, model_name, misclass_path | |
| ) | |
| # Save detailed metrics JSON | |
| metrics_path = reports_dir / f"metrics_{split}_{checkpoint_name}.json" | |
| save_metrics_json(metrics, split, model_name, metrics_path) | |
| print() | |
| # Return summary for comparison | |
| return { | |
| 'checkpoint': checkpoint_name, | |
| 'model': model_name, | |
| 'accuracy': metrics['accuracy'], | |
| 'macro_recall': metrics['macro_recall'], | |
| 'per_class_recalls': {name: m['recall'] for name, m in metrics['per_class'].items()}, | |
| 'num_params': get_model_info(model)['total_params'] | |
| } | |
| def evaluate_multiple_checkpoints( | |
| checkpoint_pattern: str, | |
| config: dict, | |
| split: str, | |
| device: str, | |
| processed_dir: Path, | |
| reports_dir: Path | |
| ): | |
| """ | |
| Evaluate multiple checkpoints and create comparison table. | |
| Args: | |
| checkpoint_pattern: Glob pattern for checkpoint files | |
| config: Configuration dictionary | |
| split: Data split to evaluate on | |
| device: Device to run on | |
| processed_dir: Directory with processed data | |
| reports_dir: Directory to save reports | |
| """ | |
| # Find all matching checkpoints | |
| checkpoint_paths = sorted(glob(checkpoint_pattern)) | |
| if len(checkpoint_paths) == 0: | |
| raise ValueError(f"No checkpoints found matching pattern: {checkpoint_pattern}") | |
| print(f"Found {len(checkpoint_paths)} checkpoints to evaluate") | |
| print() | |
| # Evaluate each checkpoint | |
| results = [] | |
| for i, checkpoint_path in enumerate(checkpoint_paths, 1): | |
| print(f"\n{'='*70}") | |
| print(f"Evaluating Checkpoint {i}/{len(checkpoint_paths)}") | |
| print(f"{'='*70}\n") | |
| result = evaluate_single_checkpoint( | |
| checkpoint_path, config, split, device, processed_dir, reports_dir | |
| ) | |
| results.append(result) | |
| # Create comparison table | |
| print("\n" + "=" * 70) | |
| print("Model Comparison") | |
| print("=" * 70) | |
| print() | |
| # Build comparison DataFrame | |
| comparison_rows = [] | |
| for result in results: | |
| row = { | |
| 'Checkpoint': result['checkpoint'], | |
| 'Model': result['model'], | |
| 'Accuracy': f"{result['accuracy']:.4f}", | |
| 'Macro Recall': f"{result['macro_recall']:.4f}", | |
| 'Parameters': f"{result['num_params']:,}" | |
| } | |
| # Add per-class recalls | |
| for class_name, recall in result['per_class_recalls'].items(): | |
| row[f'{class_name}_recall'] = f"{recall:.4f}" | |
| comparison_rows.append(row) | |
| comparison_df = pd.DataFrame(comparison_rows) | |
| # Print comparison | |
| print(comparison_df.to_string(index=False)) | |
| print() | |
| # Save comparison table | |
| comparison_path = reports_dir / f"model_comparison_{split}.csv" | |
| comparison_df.to_csv(comparison_path, index=False) | |
| print(f"Saved comparison table: {comparison_path}") | |
| def main(): | |
| """Main entry point.""" | |
| # Parse arguments | |
| args = parse_args() | |
| # Load config | |
| config = load_config(args.config) | |
| # Setup | |
| device, processed_dir, reports_dir = setup_evaluation(config) | |
| # Check if checkpoint is a glob pattern (contains wildcards) | |
| if '*' in args.checkpoint or '?' in args.checkpoint: | |
| # Multiple checkpoints | |
| evaluate_multiple_checkpoints( | |
| args.checkpoint, | |
| config, | |
| args.split, | |
| device, | |
| processed_dir, | |
| reports_dir | |
| ) | |
| else: | |
| # Single checkpoint | |
| result = evaluate_single_checkpoint( | |
| args.checkpoint, | |
| config, | |
| args.split, | |
| device, | |
| processed_dir, | |
| reports_dir | |
| ) | |
| print("\n" + "=" * 70) | |
| print("Evaluation Complete") | |
| print("=" * 70) | |
| print(f"Accuracy: {result['accuracy']:.4f}") | |
| print(f"Macro Recall: {result['macro_recall']:.4f}") | |
| print("\nDone!") | |
| if __name__ == "__main__": | |
| main() | |