#!/usr/bin/env python3 """ Model Validation Script for CVE Cybersecurity LLM Tests the trained model and generates sample responses. """ import json import logging import sys from pathlib import Path from typing import List, Dict, Any import torch from transformers import AutoTokenizer, AutoModelForCausalLM from peft import PeftModel, PeftConfig # Add project root to path project_root = Path(__file__).parent.parent.parent sys.path.insert(0, str(project_root)) # Configure logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') logger = logging.getLogger(__name__) class ModelValidator: """Validate and test the trained CVE cybersecurity model""" def __init__(self, adapter_path: str = "models/fine_tuned_cve"): self.adapter_path = Path(adapter_path) self.tokenizer = None self.model = None def load_model(self): """Load the trained model and tokenizer""" logger.info(f"Loading model from {self.adapter_path}") if not self.adapter_path.exists(): raise FileNotFoundError(f"Model path not found: {self.adapter_path}") try: # Load configuration config = PeftConfig.from_pretrained(self.adapter_path) logger.info(f"Base model: {config.base_model_name_or_path}") logger.info(f"Adapter type: {config.peft_type}") # Load tokenizer self.tokenizer = AutoTokenizer.from_pretrained(self.adapter_path) if self.tokenizer.pad_token is None: self.tokenizer.pad_token = self.tokenizer.eos_token # Load base model logger.info("Loading base model...") base_model = AutoModelForCausalLM.from_pretrained( config.base_model_name_or_path, torch_dtype=torch.float16, device_map="auto", trust_remote_code=True ) # Load LoRA adapter logger.info("Loading LoRA adapter...") self.model = PeftModel.from_pretrained(base_model, self.adapter_path) logger.info("✅ Model loaded successfully!") except Exception as e: logger.error(f"❌ Failed to load model: {e}") raise def format_query(self, query: str) -> str: """Format query for the model""" return f"""### Instruction: Analyze this cybersecurity query and provide a comprehensive response. ### Input: {query} ### Response: """ def generate_response(self, query: str, max_length: int = 512, temperature: float = 0.3) -> str: """Generate response for a given query""" try: # Format query formatted_query = self.format_query(query) # Tokenize inputs = self.tokenizer( formatted_query, return_tensors="pt", truncation=True, max_length=512 ) # Move to device inputs = {k: v.to(self.model.device) for k, v in inputs.items()} # Generate response with torch.no_grad(): outputs = self.model.generate( **inputs, max_length=max_length, temperature=temperature, do_sample=True, top_p=0.9, top_k=50, pad_token_id=self.tokenizer.eos_token_id, eos_token_id=self.tokenizer.eos_token_id, repetition_penalty=1.1, no_repeat_ngram_size=3, ) # Decode response response = self.tokenizer.decode(outputs[0], skip_special_tokens=True) # Extract only the response part response_text = response.split("### Response:")[-1].strip() return response_text except Exception as e: logger.error(f"❌ Generation failed for query '{query}': {e}") return f"Error generating response: {e}" def test_queries(self, queries: List[str]) -> List[Dict[str, str]]: """Test multiple queries and return results""" logger.info(f"Testing {len(queries)} queries...") results = [] for i, query in enumerate(queries): logger.info(f"Query {i+1}/{len(queries)}: {query}") response = self.generate_response(query) result = { 'query': query, 'response': response, 'response_length': len(response) } results.append(result) logger.info(f"Response length: {len(response)} chars") logger.info(f"Response preview: {response[:200]}...") logger.info("-" * 50) return results def save_results(self, results: List[Dict[str, str]], output_file: str = "validation_results.json"): """Save validation results to file""" output_path = self.adapter_path / output_file with open(output_path, 'w', encoding='utf-8') as f: json.dump(results, f, indent=2, ensure_ascii=False) logger.info(f"Validation results saved to {output_path}") def analyze_results(self, results: List[Dict[str, str]]): """Analyze validation results""" logger.info("📊 Analyzing validation results...") total_queries = len(results) successful_responses = sum(1 for r in results if not r['response'].startswith("Error")) avg_response_length = sum(r['response_length'] for r in results) / total_queries logger.info(f" - Total queries: {total_queries}") logger.info(f" - Successful responses: {successful_responses}/{total_queries}") logger.info(f" - Success rate: {successful_responses/total_queries*100:.1f}%") logger.info(f" - Average response length: {avg_response_length:.1f} characters") # Check for cybersecurity-specific content cybersecurity_keywords = [ 'cve', 'vulnerability', 'security', 'attack', 'exploit', 'mitigation', 'buffer overflow', 'sql injection', 'xss', 'authentication', 'authorization' ] keyword_counts = {} for keyword in cybersecurity_keywords: count = sum(1 for r in results if keyword.lower() in r['response'].lower()) keyword_counts[keyword] = count logger.info(" - Cybersecurity keyword frequency:") for keyword, count in sorted(keyword_counts.items(), key=lambda x: x[1], reverse=True): if count > 0: logger.info(f" * {keyword}: {count}/{total_queries} responses") def main(): """Main function to run model validation""" import argparse parser = argparse.ArgumentParser(description="CVE LLM Model Validation") parser.add_argument("--model_path", default="models/fine_tuned_cve", help="Path to trained model") parser.add_argument("--output", default="validation_results.json", help="Output file for results") args = parser.parse_args() # Test queries test_queries = [ "Analyze the CVE-2021-44228 Log4j vulnerability", "What are the most critical vulnerabilities in Apache products?", "Explain the impact of SQL injection vulnerabilities", "How can I remediate buffer overflow vulnerabilities?", "What are the common attack patterns for web applications?", "Describe the MITRE ATT&CK framework and its relevance to CVE analysis", "What is the difference between CVE and CWE?", "How do I assess the severity of a vulnerability?", "What are the best practices for vulnerability management?", "Explain the concept of zero-day vulnerabilities" ] try: # Initialize validator validator = ModelValidator(args.model_path) # Load model validator.load_model() # Test queries results = validator.test_queries(test_queries) # Save results validator.save_results(results, args.output) # Analyze results validator.analyze_results(results) logger.info("✅ Model validation completed successfully!") except Exception as e: logger.error(f"❌ Model validation failed: {e}") raise if __name__ == "__main__": main()