Upload 5 files

demo.py

@@ -0,0 +1,161 @@
+import pandas as pd
+from unsloth import FastLanguageModel
+from transformers import TextStreamer
+import torch
+import random
+import logging
+
+def setup_logging():
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s - %(message)s'
+    )
+    return logging.getLogger(__name__)
+
+def print_separator(title="", char="=", length=80):
+    """Print a separator with optional title"""
+    if title:
+        side_length = (length - len(title) - 2) // 2
+        print(char * side_length + f" {title} " + char * side_length)
+    else:
+        print(char * length)
+
+def format_flow_prompt(row):
+    """Format a single network flow into a prompt"""
+    flow_text = f"""Network Flow Description:
+Source: {row['IPV4_SRC_ADDR']} (Port: {row['L4_SRC_PORT']})
+Destination: {row['IPV4_DST_ADDR']} (Port: {row['L4_DST_PORT']})
+Protocol Information:
+- Protocol ID: {row['PROTOCOL']}
+- Layer 7 Protocol: {row['L7_PROTO']}
+- TCP Flags: {row['TCP_FLAGS']}
+Traffic Metrics:
+- Bytes: {row['IN_BYTES']} inbound, {row['OUT_BYTES']} outbound
+- Packets: {row['IN_PKTS']} inbound, {row['OUT_PKTS']} outbound
+- Duration: {row['FLOW_DURATION_MILLISECONDS']} milliseconds"""
+
+    # Format in LLaMA-3 style
+    return f"""<|begin_of_text|><|start_header_id|>user<|end_header_id|>
+Analyze this network flow for potential security threats:
+
+{flow_text}<|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+
+def analyze_single_flow(model_path="cybersec_model_output/checkpoint-4329", 
+                       test_file="data/test.csv", 
+                       index=None,
+                       attack_type=None):
+    """Analyze a single network flow and show the model's complete response"""
+    logger = setup_logging()
+    
+    print_separator("LOADING DATA AND MODEL", "=")
+    # Load test data
+    logger.info(f"Loading test data from {test_file}")
+    test_df = pd.read_csv(test_file)
+    
+    # Select sample based on criteria
+    if attack_type:
+        attack_samples = test_df[test_df['Attack'].str.lower() == attack_type.lower()]
+        if len(attack_samples) == 0:
+            raise ValueError(f"No samples found for attack type: {attack_type}")
+        sample = attack_samples.iloc[random.randint(0, len(attack_samples)-1)]
+    elif index is not None:
+        sample = test_df.iloc[index]
+    else:
+        sample = test_df.iloc[random.randint(0, len(test_df)-1)]
+    
+    # Load model
+    logger.info(f"Loading model from {model_path}")
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_path,
+        max_seq_length=2048,
+        load_in_4bit=True,
+    )
+    
+    # Set up tokenizer
+    tokenizer.pad_token = tokenizer.eos_token
+    tokenizer.padding_side = "right"
+    FastLanguageModel.for_inference(model)
+    
+    print_separator("SAMPLE INFORMATION", "=")
+    logger.info(f"Selected flow index: {sample.name}")
+    logger.info(f"True label: {sample['Attack']}")
+    
+    # Prepare input
+    prompt = format_flow_prompt(sample)
+    inputs = tokenizer(
+        prompt,
+        return_tensors="pt",
+        truncation=True,
+        max_length=2048
+    ).to("cuda")
+    
+    # Set up streamer for real-time output
+    streamer = TextStreamer(tokenizer)
+    
+    with open("model_output.txt", "w") as f:
+        # Write separators and metadata
+        f.write("=" * 80 + "\n")
+        f.write(f"NETWORK FLOW ANALYSIS\n")
+        f.write("=" * 80 + "\n\n")
+        
+        f.write("-" * 80 + "\n")
+        f.write("METADATA\n")
+        f.write("-" * 80 + "\n")
+        f.write(f"Flow Index: {sample.name}\n")
+        f.write(f"True Label: {sample['Attack']}\n\n")
+        
+        f.write("-" * 80 + "\n")
+        f.write("INPUT PROMPT\n")
+        f.write("-" * 80 + "\n")
+        f.write(f"{prompt}\n\n")
+        
+        print_separator("MODEL OUTPUT", "=")
+        logger.info("Generating analysis...")
+        
+        # Generate and capture output
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=256,
+            streamer=streamer,
+            use_cache=True
+        )
+        
+        # Write the complete output
+        f.write("-" * 80 + "\n")
+        f.write("COMPLETE OUTPUT (including special tokens)\n")
+        f.write("-" * 80 + "\n")
+        full_output = tokenizer.decode(outputs[0], skip_special_tokens=False)
+        f.write(f"{full_output}\n\n")
+        
+        # Write cleaned output
+        f.write("-" * 80 + "\n")
+        f.write("CLEANED OUTPUT (without special tokens)\n")
+        f.write("-" * 80 + "\n")
+        cleaned_output = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        f.write(cleaned_output)
+        
+        f.write("\n" + "=" * 80 + "\n")
+    
+    print_separator()
+    logger.info("Output saved to model_output.txt")
+    print_separator()
+
+def main():
+    # Example usage:
+    print_separator("STARTING ANALYSIS", "=")
+    
+    # Choose one of these options:
+    
+    # 1. Random sample
+    analyze_single_flow()
+    
+    # 2. Specific attack type
+    # analyze_single_flow(attack_type="ddos")
+    
+    # 3. Specific index
+    # analyze_single_flow(index=42)
+    
+    print_separator("ANALYSIS COMPLETE", "=")
+
+if __name__ == "__main__":
+    main()

evaluate.py

@@ -0,0 +1,203 @@
+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()

split_dataset.py

@@ -0,0 +1,80 @@
+import pandas as pd
+import numpy as np
+from pathlib import Path
+import argparse
+import logging
+from sklearn.model_selection import train_test_split
+
+def setup_logging():
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s - %(message)s'
+    )
+    return logging.getLogger(__name__)
+
+def split_dataset(input_path: str, output_dir: str, chunk_size: int = 100000):
+    """
+    Split a large CSV file into train, test, and validation sets.
+    Processes the file in chunks to handle large datasets efficiently.
+    
+    Args:
+        input_path: Path to input CSV file
+        output_dir: Directory to save split datasets
+        chunk_size: Number of rows to process at a time
+    """
+    logger = setup_logging()
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+    
+    # Open output files
+    train_file = open(output_path / 'train.csv', 'w')
+    test_file = open(output_path / 'test.csv', 'w')
+    val_file = open(output_path / 'val.csv', 'w')
+    
+    # Set random seed for reproducibility
+    np.random.seed(42)
+    
+    # Process the CSV in chunks
+    chunk_iterator = pd.read_csv(input_path, chunksize=chunk_size)
+    
+    is_first_chunk = True
+    total_rows = 0
+    
+    logger.info("Starting dataset split...")
+    
+    for i, chunk in enumerate(chunk_iterator):
+        # Split chunk into train (70%), test (20%), val (10%)
+        train_chunk, test_val_chunk = train_test_split(chunk, train_size=0.7, random_state=42)
+        test_chunk, val_chunk = train_test_split(test_val_chunk, train_size=0.67, random_state=42)
+        
+        # Write header for first chunk only
+        if is_first_chunk:
+            train_chunk.to_csv(train_file, index=False)
+            test_chunk.to_csv(test_file, index=False)
+            val_chunk.to_csv(val_file, index=False)
+            is_first_chunk = False
+        else:
+            train_chunk.to_csv(train_file, index=False, header=False)
+            test_chunk.to_csv(test_file, index=False, header=False)
+            val_chunk.to_csv(val_file, index=False, header=False)
+        
+        total_rows += len(chunk)
+        logger.info(f"Processed {total_rows} rows...")
+    
+    # Close files
+    train_file.close()
+    test_file.close()
+    val_file.close()
+    
+    logger.info("Dataset splitting complete!")
+    logger.info(f"Total rows processed: {total_rows}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Split large CSV dataset into train/test/val sets")
+    parser.add_argument("--input_path", required=True, help="Path to input CSV file")
+    parser.add_argument("--output_dir", required=True, help="Directory to save split datasets")
+    parser.add_argument("--chunk_size", type=int, default=100000, help="Chunk size for processing")
+    
+    args = parser.parse_args()
+    
+    split_dataset(args.input_path, args.output_dir, args.chunk_size)

test.py

@@ -0,0 +1,140 @@
+import torch
+from unsloth import FastLanguageModel
+import pandas as pd
+from transformers import TextStreamer
+import logging
+from typing import List, Dict
+import json
+
+def setup_logging():
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s - %(message)s'
+    )
+    return logging.getLogger(__name__)
+
+class NetworkFlowAnalyzer:
+    def __init__(self, model_path: str):
+        self.logger = setup_logging()
+        self.logger.info(f"Loading model from {model_path}")
+        
+        # Load model and tokenizer
+        self.model, self.tokenizer = FastLanguageModel.from_pretrained(
+            model_path,
+            max_seq_length=2048,
+            load_in_4bit=True,
+        )
+        
+        # Enable faster inference
+        FastLanguageModel.for_inference(self.model)
+        
+        # Set up tokenizer for generation
+        self.tokenizer.pad_token = self.tokenizer.eos_token
+        self.tokenizer.padding_side = "right"
+        
+    def format_flow_prompt(self, row: pd.Series) -> str:
+        """Format a network flow into a prompt"""
+        flow_text = f"""Network Flow Description:
+Source: {row['IPV4_SRC_ADDR']} (Port: {row['L4_SRC_PORT']})
+Destination: {row['IPV4_DST_ADDR']} (Port: {row['L4_DST_PORT']})
+Protocol Information:
+- Protocol ID: {row['PROTOCOL']}
+- Layer 7 Protocol: {row['L7_PROTO']}
+- TCP Flags: {row['TCP_FLAGS']}
+Traffic Metrics:
+- Bytes: {row['IN_BYTES']} inbound, {row['OUT_BYTES']} outbound
+- Packets: {row['IN_PKTS']} inbound, {row['OUT_PKTS']} outbound
+- Duration: {row['FLOW_DURATION_MILLISECONDS']} milliseconds"""
+
+        # Format in LLaMA-3 style
+        return f"""<|begin_of_text|><|start_header_id|>user<|end_header_id|>
+Analyze this network flow for potential security threats:
+
+{flow_text}<|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+
+    def analyze_flow(self, row: pd.Series, max_new_tokens: int = 256, stream: bool = False) -> str:
+        """Analyze a single network flow"""
+        # Prepare input
+        prompt = self.format_flow_prompt(row)
+        inputs = self.tokenizer(
+            prompt, 
+            return_tensors="pt",
+            truncation=True,
+            max_length=2048
+        ).to("cuda")
+        
+        # Set up streamer if requested
+        streamer = TextStreamer(self.tokenizer) if stream else None
+        
+        # Generate prediction
+        outputs = self.model.generate(
+            **inputs,
+            max_new_tokens=max_new_tokens,
+            streamer=streamer,
+            use_cache=True
+        )
+        
+        if not stream:
+            return self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+        return None
+
+    def analyze_batch(self, df: pd.DataFrame, output_file: str = None) -> List[Dict]:
+        """Analyze a batch of network flows"""
+        results = []
+        
+        for idx, row in df.iterrows():
+            self.logger.info(f"Analyzing flow {idx+1}/{len(df)}")
+            
+            try:
+                analysis = self.analyze_flow(row)
+                result = {
+                    "flow_id": idx,
+                    "source_ip": row["IPV4_SRC_ADDR"],
+                    "destination_ip": row["IPV4_DST_ADDR"],
+                    "analysis": analysis,
+                    "true_label": row.get("Label", "Unknown"),
+                    "attack_type": row.get("Attack", "Unknown")
+                }
+                results.append(result)
+                
+            except Exception as e:
+                self.logger.error(f"Error analyzing flow {idx}: {str(e)}")
+                continue
+        
+        if output_file:
+            with open(output_file, 'w') as f:
+                json.dump(results, f, indent=2)
+        
+        return results
+
+def main():
+    logger = setup_logging()
+    
+    # Initialize analyzer
+    analyzer = NetworkFlowAnalyzer("cybersec_model_output/checkpoint-4329")
+    
+    # Load test data
+    test_df = pd.read_csv("data/test.csv")
+    logger.info(f"Loaded {len(test_df)} test samples")
+    
+    # Option 1: Stream analysis of a single flow
+    logger.info("\nAnalyzing single flow with streaming:")
+    analyzer.analyze_flow(test_df.iloc[0], stream=True)
+    
+    # Option 2: Batch analysis
+    logger.info("\nAnalyzing batch of flows:")
+    sample_size = min(100, len(test_df))  # Analyze first 100 flows
+    results = analyzer.analyze_batch(
+        test_df.head(sample_size),
+        output_file="analysis_results.json"
+    )
+    
+    # Print some statistics
+    logger.info(f"\nAnalyzed {len(results)} flows")
+    if "Label" in test_df.columns:
+        true_positives = sum(1 for r in results if "malicious" in r["analysis"].lower() 
+                           and r["true_label"] == 1)
+        logger.info(f"Detected {true_positives} potentially malicious flows")
+
+if __name__ == "__main__":
+    main()

train.py

@@ -0,0 +1,196 @@
+import os
+os.environ["CUDA_VISIBLE_DEVICES"]="3"
+import torch
+from datasets import Dataset
+from unsloth import FastLanguageModel
+import pandas as pd
+import numpy as np
+from sklearn.preprocessing import MinMaxScaler
+from transformers import TrainingArguments
+from trl import SFTTrainer
+import logging
+from typing import List, Dict
+import json
+
+def setup_logging():
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s - %(levelname)s - %(message)s'
+    )
+    return logging.getLogger(__name__)
+def sample_balanced_dataset(df, max_samples_per_class=1000):
+    """Sample a balanced subset of the data"""
+    sampled_dfs = []
+    
+    # Handle 'benign' class separately
+    benign_df = df[df['Attack'].str.lower() == 'benign']
+    attack_df = df[df['Attack'].str.lower() != 'benign']
+    
+    # Sample benign data
+    if len(benign_df) > max_samples_per_class:
+        benign_sampled = benign_df.sample(n=max_samples_per_class, random_state=42)
+        sampled_dfs.append(benign_sampled)
+    else:
+        sampled_dfs.append(benign_df)
+    
+    # Sample each attack type
+    for attack_type in attack_df['Attack'].unique():
+        attack_type_df = attack_df[attack_df['Attack'] == attack_type]
+        if len(attack_type_df) > max_samples_per_class:
+            sampled = attack_type_df.sample(n=max_samples_per_class, random_state=42)
+            sampled_dfs.append(sampled)
+        else:
+            sampled_dfs.append(attack_type_df)
+    
+    return pd.concat(sampled_dfs, ignore_index=True)
+
+class NetworkFlowDataProcessor:
+    def __init__(self):
+        self.logger = setup_logging()
+        self.scaler = MinMaxScaler()
+        self.numerical_features = [
+            'L4_SRC_PORT', 'L4_DST_PORT', 'PROTOCOL', 'L7_PROTO',
+            'IN_BYTES', 'OUT_BYTES', 'IN_PKTS', 'OUT_PKTS',
+            'TCP_FLAGS', 'FLOW_DURATION_MILLISECONDS'
+        ]
+        self.categorical_features = ['IPV4_SRC_ADDR', 'IPV4_DST_ADDR']
+        
+    def process_ip_address(self, ip: str) -> str:
+        """Convert IP address to a more descriptive format"""
+        parts = ip.split('.')
+        if parts[0] == '192' and parts[1] == '168':
+            return f"internal_network_{parts[2]}_{parts[3]}"
+        return f"external_network_{ip}"
+
+    def format_flow_data(self, row: pd.Series) -> str:
+        """Format network flow data into a descriptive text"""
+        return f"""Network Flow Description:
+Source: {self.process_ip_address(row['IPV4_SRC_ADDR'])} (Port: {row['L4_SRC_PORT']})
+Destination: {self.process_ip_address(row['IPV4_DST_ADDR'])} (Port: {row['L4_DST_PORT']})
+Protocol Information:
+- Protocol ID: {row['PROTOCOL']}
+- Layer 7 Protocol: {row['L7_PROTO']}
+- TCP Flags: {row['TCP_FLAGS']}
+Traffic Metrics:
+- Bytes: {row['IN_BYTES']} inbound, {row['OUT_BYTES']} outbound
+- Packets: {row['IN_PKTS']} inbound, {row['OUT_PKTS']} outbound
+- Duration: {row['FLOW_DURATION_MILLISECONDS']} milliseconds"""
+
+    def get_attack_description(self, attack_type: str) -> str:
+        """Get detailed description of attack type"""
+        descriptions = {
+            "benign": "This is normal network traffic with no malicious intent.",
+            "ddos": "A Distributed Denial of Service attack attempting to overwhelm network resources.",
+            "dos": "A Denial of Service attack targeting system availability.",
+            "injection": "An attack attempting to inject malicious code or commands.",
+            "scanning": "Network scanning activity to discover vulnerabilities.",
+            "backdoor": "Malicious activity indicating backdoor access attempts.",
+            "mitm": "Man-in-the-Middle attack intercepting network communications.",
+            "password": "Password-based attack attempting unauthorized access.",
+            "ransomware": "Ransomware-related network activity.",
+            "xss": "Cross-Site Scripting attack targeting web applications."
+        }
+        return descriptions.get(attack_type.lower(), "Unknown attack type")
+
+    def prepare_training_text(self, row: pd.Series) -> str:
+        """Prepare single training example in LLaMA-3 chat format"""
+        flow_text = self.format_flow_data(row)
+        attack_type = row['Attack'].lower() if 'Attack' in row else 'benign'
+        attack_desc = self.get_attack_description(attack_type)
+        
+        return f"""<|begin_of_text|><|start_header_id|>user<|end_header_id|>
+Analyze this network flow for potential security threats:
+
+{flow_text}<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+This network flow is classified as {attack_type}. {attack_desc}
+
+Key indicators from the flow data:
+- Traffic volume: {row['IN_BYTES'] + row['OUT_BYTES']} total bytes
+- Flow duration: {row['FLOW_DURATION_MILLISECONDS']} ms
+- Protocol behavior: {row['TCP_FLAGS']} TCP flags<|eot_id|>"""
+
+def load_and_process_data(train_path: str, processor: NetworkFlowDataProcessor, max_samples_per_class=50000):
+    """Load and process the training data"""
+    logger = setup_logging()
+    logger.info(f"Loading data from {train_path}")
+    
+    df = pd.read_csv(train_path)
+    df = sample_balanced_dataset(df, max_samples_per_class)
+    logger.info(f"Sampled dataset size: {len(df)}")
+    
+    # Create dataset with text field
+    texts = [processor.prepare_training_text(row) for _, row in df.iterrows()]
+    dataset = Dataset.from_pandas(pd.DataFrame({'text': texts}))
+    
+    return dataset
+
+def main():
+    logger = setup_logging()
+    
+    # Initialize data processor
+    processor = NetworkFlowDataProcessor()
+    
+    # Load and process data
+    train_dataset = load_and_process_data("data/train.csv", processor, max_samples_per_class=50000)
+    
+    # Model initialization
+    model, tokenizer = FastLanguageModel.from_pretrained(
+        model_name="unsloth/llama-3-8b-Instruct-bnb-4bit",
+        max_seq_length=2048,
+        load_in_4bit=True,
+    )
+    
+    # Configure tokenizer for LLaMA-3
+    tokenizer.pad_token = tokenizer.eos_token
+    tokenizer.padding_side = "right"
+    
+    # Add LoRA adapters
+    model = FastLanguageModel.get_peft_model(
+        model,
+        r=16,
+        target_modules=[
+            "q_proj", "k_proj", "v_proj", "o_proj",
+            "gate_proj", "up_proj", "down_proj",
+        ],
+        lora_alpha=16,
+        lora_dropout=0,
+        bias="none",
+        use_gradient_checkpointing="unsloth",
+        random_state=3407,
+    )
+    
+    # Configure training arguments
+    training_args = TrainingArguments(
+        output_dir="cybersec_model_output",
+        num_train_epochs=3,
+        per_device_train_batch_size=64,
+        gradient_accumulation_steps=4,
+        learning_rate=2e-4,
+        bf16=True,  # Use bfloat16 for A100
+        logging_steps=10,
+        save_strategy="epoch",
+        optim="adamw_8bit",
+        lr_scheduler_type="cosine",
+    )
+    
+    # Initialize trainer
+    trainer = SFTTrainer(
+        model=model,
+        tokenizer=tokenizer,
+        train_dataset=train_dataset,
+        dataset_text_field="text",  # Changed from conversations to text
+        max_seq_length=2048,
+        args=training_args,
+    )
+    
+    # Train the model
+    logger.info("Starting training...")
+    trainer.train()
+    
+    # Save the model
+    logger.info("Saving model...")
+    model.save_pretrained("cybersec_model")
+    tokenizer.save_pretrained("cybersec_model")
+
+if __name__ == "__main__":
+    main()