base_eval.py

import pandas as pd
import numpy as np
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
from tqdm import tqdm
import logging
import argparse
from pathlib import Path
from sklearn.metrics import classification_report, accuracy_score, roc_auc_score
import json

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

def format_flow_prompt(row):
    """Format a single network flow into a prompt for the model"""
    messages = [
        {"role": "system", "content": "You are a cybersecurity expert analyzing network flows for potential security threats. You must classify each flow as either malicious or benign based on its characteristics. Respond with only the word 'malicious' or 'benign'."},
        {"role": "user", "content": f"""Analyze this network flow:
Source IP: {row['IPV4_SRC_ADDR']} (Port: {row['L4_SRC_PORT']})
Destination IP: {row['IPV4_DST_ADDR']} (Port: {row['L4_DST_PORT']})
Protocol: {row['PROTOCOL']}
Layer 7 Protocol: {row['L7_PROTO']}
Traffic Volume: {row['IN_BYTES']} bytes in, {row['OUT_BYTES']} bytes out
Packets: {row['IN_PKTS']} packets in, {row['OUT_PKTS']} packets out
TCP Flags: {row['TCP_FLAGS']}
Duration: {row['FLOW_DURATION_MILLISECONDS']} ms

Is this network flow malicious or benign? Answer with only one word."""}
    ]
    return messages

class ZeroShotTester:
    def __init__(self, device="cuda"):
        """Initialize the model and tokenizer"""
        self.logger = setup_logging()
        self.device = device
        model_name = "meta-llama/Meta-Llama-3.1-8B-Instruct"
        
        self.logger.info(f"Loading model {model_name}...")
        self.tokenizer = AutoTokenizer.from_pretrained(
            model_name,
            use_fast=True
        )
        # Set pad token to eos token
        self.tokenizer.pad_token = self.tokenizer.eos_token
        
        self.model = AutoModelForCausalLM.from_pretrained(
            model_name,
            torch_dtype=torch.float16,
            device_map="auto",
            pad_token_id=self.tokenizer.eos_token_id  # Set pad token ID in model
        )
        
    def predict_single(self, messages):
        """Generate prediction for a single prompt"""
        # Prepare input
        encodings = self.tokenizer.apply_chat_template(
            messages,
            add_generation_prompt=True,
            return_tensors="pt"
        )
        
        # Create attention mask
        attention_mask = torch.ones_like(encodings)
        
        # Move to device
        input_ids = encodings.to(self.device)
        attention_mask = attention_mask.to(self.device)
        
        # Generate prediction
        with torch.no_grad():
            outputs = self.model.generate(
                input_ids=input_ids,
                attention_mask=attention_mask,
                max_new_tokens=5,  # We only need one word
                do_sample=False,  # Deterministic output
                temperature=0.1,  # Low temperature for more focused output
                pad_token_id=self.tokenizer.pad_token_id
            )
        
        # Extract response
        response = outputs[0][input_ids.shape[-1]:]
        response_text = self.tokenizer.decode(response, skip_special_tokens=True).strip().lower()
        
        # Classify output
        return 1 if 'malicious' in response_text else 0
    
    def evaluate_dataset(self, test_path, batch_size=32, max_samples=None):
        """Evaluate the model on a test dataset"""
        self.logger.info(f"Starting evaluation on {test_path}")
        
        # Read and process the test set in chunks
        chunk_iterator = pd.read_csv(test_path, chunksize=batch_size)
        all_predictions = []
        all_labels = []
        total_processed = 0
        
        try:
            for chunk in tqdm(chunk_iterator, desc="Processing batches"):
                if max_samples and total_processed >= max_samples:
                    break
                    
                # Generate prompts for the chunk
                prompts = [format_flow_prompt(row) for _, row in chunk.iterrows()]
                
                # Get predictions
                predictions = []
                for prompt in prompts:
                    try:
                        pred = self.predict_single(prompt)
                        predictions.append(pred)
                    except Exception as e:
                        self.logger.error(f"Error processing prompt: {e}")
                        predictions.append(0)  # Default to benign on error
                
                all_predictions.extend(predictions)
                all_labels.extend(chunk['Label'].tolist())
                
                total_processed += len(chunk)
                if total_processed % 100 == 0:
                    self.logger.info(f"Processed {total_processed} samples...")
                    
                    # Calculate and log intermediate metrics
                    curr_accuracy = accuracy_score(all_labels, all_predictions)
                    curr_auc = roc_auc_score(all_labels, all_predictions)
                    successful_samples = sum(1 for p in predictions if p is not None)
                    self.logger.info(f"Current Accuracy: {curr_accuracy:.4f}, AUC: {curr_auc:.4f}")
                    self.logger.info(f"Successfully processed samples in this batch: {successful_samples}/{len(predictions)}")
        
        except Exception as e:
            self.logger.error(f"Error during evaluation: {e}")
            if len(all_predictions) == 0:
                raise
        
        # Calculate final metrics
        accuracy = accuracy_score(all_labels[:total_processed], all_predictions[:total_processed])
        auc = roc_auc_score(all_labels[:total_processed], all_predictions[:total_processed])
        report = classification_report(all_labels[:total_processed], all_predictions[:total_processed])
        
        return {
            'accuracy': accuracy,
            'auc': auc,
            'classification_report': report,
            'total_samples': total_processed,
            'predictions': all_predictions[:total_processed],
            'true_labels': all_labels[:total_processed]
        }

def main():
    parser = argparse.ArgumentParser(description="Zero-shot testing of LLaMA 3.1 on network flows")
    parser.add_argument("--test_path", required=True, help="Path to test CSV file")
    parser.add_argument("--output_dir", required=True, help="Directory to save results")
    parser.add_argument("--batch_size", type=int, default=32, help="Batch size for processing")
    parser.add_argument("--max_samples", type=int, default=None, 
                       help="Maximum number of samples to test (None for all)")
    
    args = parser.parse_args()
    logger = setup_logging()
    
    # Create output directory
    output_path = Path(args.output_dir)
    output_path.mkdir(parents=True, exist_ok=True)
    
    # Initialize tester
    tester = ZeroShotTester()
    
    try:
        # Evaluate model
        results = tester.evaluate_dataset(
            args.test_path,
            batch_size=args.batch_size,
            max_samples=args.max_samples
        )
        
        # Save results
        logger.info("\nFinal Results:")
        logger.info(f"Total samples processed: {results['total_samples']}")
        logger.info(f"Successfully processed samples: {sum(1 for p in results['predictions'] if p is not None)}")
        logger.info(f"Accuracy: {results['accuracy']:.4f}")
        logger.info(f"AUC: {results['auc']:.4f}")
        logger.info("\nClassification Report:")
        logger.info(results['classification_report'])
        
        # Save detailed results
        with open(output_path / 'zero_shot_results.json', 'w') as f:
            # Convert numpy arrays to lists for JSON serialization
            results['predictions'] = [int(p) for p in results['predictions']]
            results['true_labels'] = [int(l) for l in results['true_labels']]
            json.dump(results, f, indent=4)
            
    except Exception as e:
        logger.error(f"Error in main execution: {e}")
        raise

if __name__ == "__main__":
    main()