evaluate.py

import json
import pandas as pd
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
import numpy as np
import re
from typing import Dict, List, Tuple
import logging
from collections import defaultdict

def setup_logging():
    logging.basicConfig(
        level=logging.INFO,
        format='%(asctime)s - %(levelname)s - %(message)s'
    )
    return logging.getLogger(__name__)

class ModelEvaluator:
    def __init__(self):
        self.logger = setup_logging()
        self.attack_types = {
            'benign': ['benign', 'normal', 'legitimate'],
            'dos': ['dos', 'denial of service'],
            'ddos': ['ddos', 'distributed denial of service'],
            'injection': ['injection', 'sql injection', 'command injection'],
            'scanning': ['scanning', 'port scan', 'network scan'],
            'password': ['password', 'brute force', 'credential'],
            'mitm': ['mitm', 'man in the middle'],
            'backdoor': ['backdoor'],
            'ransomware': ['ransomware'],
            'xss': ['xss', 'cross site scripting']
        }

    def extract_prediction(self, analysis_text: str) -> str:
        """Extract the predicted attack type from model output"""
        analysis_text = analysis_text.lower()
        
        # First check if there's an explicit classification
        match = re.search(r"classified as (\w+)", analysis_text)
        if match:
            return match.group(1)
            
        # Check for each attack type in the text
        for attack_type, keywords in self.attack_types.items():
            for keyword in keywords:
                if keyword in analysis_text:
                    return attack_type
                    
        # Default to benign if no attack type is found
        return 'benign'

    def evaluate_results(self, results_file: str, test_data_file: str) -> Dict:
        """Evaluate model predictions against ground truth"""
        # Load results and test data
        with open(results_file, 'r') as f:
            results = json.load(f)
        test_df = pd.read_csv(test_data_file)
        
        # Extract predictions and true labels
        predictions = []
        true_labels = []
        confidence_scores = defaultdict(list)
        
        for result in results:
            flow_id = result['flow_id']
            true_label = test_df.iloc[flow_id]['Attack'].lower()
            prediction = self.extract_prediction(result['analysis'])
            
            predictions.append(prediction)
            true_labels.append(true_label)
            
            # Track prediction confidence
            confidence = 1.0
            if 'possibly' in result['analysis'].lower() or 'potential' in result['analysis'].lower():
                confidence = 0.7
            if 'suspicious' in result['analysis'].lower():
                confidence = 0.8
            confidence_scores[prediction].append(confidence)
        
        # Calculate metrics
        accuracy = float(accuracy_score(true_labels, predictions))
        class_report = classification_report(true_labels, predictions, 
                                          labels=list(self.attack_types.keys()),
                                          output_dict=True)
        conf_matrix = confusion_matrix(true_labels, predictions, 
                                     labels=list(self.attack_types.keys()))
        
        # Calculate average confidence per class
        avg_confidence = {k: float(np.mean(v)) if v else 0.0 
                         for k, v in confidence_scores.items()}
        
        # Analyze error patterns
        error_analysis = self.analyze_errors(true_labels, predictions, results)
        
        # Prepare metrics for JSON serialization
        metrics = {
            'accuracy': accuracy,
            'classification_report': {},
            'confusion_matrix': conf_matrix.tolist(),
            'average_confidence': avg_confidence,
            'error_analysis': error_analysis
        }
        
        # Process classification report for JSON serialization
        for class_name, metrics_dict in class_report.items():
            if isinstance(metrics_dict, dict):
                metrics['classification_report'][class_name] = {
                    k: float(v) for k, v in metrics_dict.items()
                    if isinstance(v, (int, float, np.number))
                }
        
        return metrics
    
    def analyze_errors(self, true_labels: List[str], predictions: List[str], 
                      results: List[Dict]) -> Dict:
        """Analyze patterns in model errors"""
        error_patterns = {
            'false_positives': defaultdict(list),
            'false_negatives': defaultdict(list),
        }
        
        for idx, (true, pred, result) in enumerate(zip(true_labels, predictions, results)):
            if true != pred:
                # Track the specific flow details for this error
                flow_details = {
                    'flow_id': result['flow_id'],
                    'source_ip': result['source_ip'],
                    'destination_ip': result['destination_ip'],
                    'model_explanation': result['analysis']
                }
                
                # Categorize error type
                if true == 'benign':
                    error_patterns['false_positives'][pred].append(flow_details)
                else:
                    error_patterns['false_negatives'][true].append(flow_details)
        
        # Convert defaultdict to regular dict for JSON serialization
        return {
            'false_positives': dict(error_patterns['false_positives']),
            'false_negatives': dict(error_patterns['false_negatives'])
        }

    def print_evaluation_summary(self, metrics: Dict):
        """Print a human-readable summary of evaluation metrics"""
        self.logger.info("\n=== Model Evaluation Summary ===")
        
        # Overall Accuracy
        self.logger.info(f"\nOverall Accuracy: {metrics['accuracy']:.4f}")
        
        # Per-class Performance
        self.logger.info("\nPer-class Performance:")
        class_metrics = metrics['classification_report']
        for class_name in self.attack_types.keys():
            if class_name in class_metrics:
                metrics_dict = class_metrics[class_name]
                self.logger.info(f"\n{class_name.upper()}:")
                self.logger.info(f"  Precision: {metrics_dict.get('precision', 0):.4f}")
                self.logger.info(f"  Recall: {metrics_dict.get('recall', 0):.4f}")
                self.logger.info(f"  F1-Score: {metrics_dict.get('f1-score', 0):.4f}")
                if class_name in metrics['average_confidence']:
                    self.logger.info(f"  Avg Confidence: {metrics['average_confidence'][class_name]:.4f}")
        
        # Error Analysis Summary
        self.logger.info("\nError Analysis Summary:")
        error_analysis = metrics['error_analysis']
        
        # False Positives
        self.logger.info("\nMost Common False Positives:")
        for attack_type, errors in error_analysis['false_positives'].items():
            self.logger.info(f"  {attack_type}: {len(errors)} instances")
            
        # False Negatives
        self.logger.info("\nMost Common False Negatives:")
        for attack_type, errors in error_analysis['false_negatives'].items():
            self.logger.info(f"  {attack_type}: {len(errors)} instances")

def main():
    logger = setup_logging()
    
    # Initialize evaluator
    evaluator = ModelEvaluator()
    
    try:
        # Evaluate results
        metrics = evaluator.evaluate_results(
            results_file='analysis_results.json',
            test_data_file='data/test.csv'
        )
        
        # Print evaluation summary
        evaluator.print_evaluation_summary(metrics)
        
        # Save detailed metrics
        with open('evaluation_metrics.json', 'w') as f:
            json.dump(metrics, f, indent=2)
            logger.info("\nSaved detailed metrics to evaluation_metrics.json")
            
    except Exception as e:
        logger.error(f"Error during evaluation: {str(e)}")
        raise

if __name__ == "__main__":
    main()