Delete notebooks

notebooks/00_download_datasets.ipynb

@@ -1,297 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "23987af9",
-   "metadata": {},
-   "source": [
-    "# 📥 Security Dataset Download & Preparation\n",
-    "\n",
-    "This notebook downloads and prepares all security datasets for training.\n",
-    "Run this notebook **once** before training any models.\n",
-    "\n",
-    "## Datasets Included:\n",
-    "- **Phishing Detection**: Malicious URLs, phishing websites\n",
-    "- **Malware Analysis**: PE features, Android malware\n",
-    "- **Network Intrusion**: NSL-KDD, CICIDS, UNSW-NB15\n",
-    "- **Web Attacks**: XSS, SQL injection, CSRF\n",
-    "- **Threat Intelligence**: Malicious IPs, botnet C2\n",
-    "- **DNS Security**: DGA detection\n",
-    "- **Spam Detection**: Email classification"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "b888df31",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Note: you may need to restart the kernel to use updated packages.\n",
-      "✅ Dependencies installed\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Install required packages using pip magic (ensures correct kernel environment)\n",
-    "%pip install -q pandas numpy certifi nest_asyncio tqdm\n",
-    "\n",
-    "print('✅ Dependencies installed')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "53a35426",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "✅ Dataset manager imported\n"
-     ]
-    }
-   ],
-   "source": [
-    "import sys\n",
-    "import asyncio\n",
-    "from pathlib import Path\n",
-    "\n",
-    "# Add project path\n",
-    "sys.path.insert(0, str(Path.cwd().parent / 'app' / 'services'))\n",
-    "\n",
-    "# Import dataset manager\n",
-    "from web_security_datasets import WebSecurityDatasetManager\n",
-    "\n",
-    "# For Jupyter async support\n",
-    "try:\n",
-    "    import nest_asyncio\n",
-    "    nest_asyncio.apply()\n",
-    "except:\n",
-    "    pass\n",
-    "\n",
-    "print('✅ Dataset manager imported')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "e831a641",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "📊 Available Security Datasets:\n",
-      "   Categories: ['phishing', 'web_attack', 'cryptomining', 'dns', 'malware', 'threat_intel', 'logs', 'spam', 'ssl', 'intrusion']\n",
-      "   Total datasets: 18\n",
-      "   Estimated samples: 1,072,129\n",
-      "\n",
-      "📋 Dataset List:\n",
-      "   • url_phishing_kaggle: Malicious vs Benign URLs (Kaggle) [phishing]\n",
-      "   • phishing_websites_uci: UCI Phishing Websites Dataset [phishing]\n",
-      "   • malware_pe_features: PE Header Malware Features [malware]\n",
-      "   • android_malware_drebin: Android Malware (Drebin-style Features) [malware]\n",
-      "   • cicids2017_ddos: CICIDS 2017 DDoS Detection [intrusion]\n",
-      "   • nsl_kdd_train: NSL-KDD Network Intrusion [intrusion]\n",
-      "   • unsw_nb15: UNSW-NB15 Network Dataset [intrusion]\n",
-      "   • ipsum_malicious_ips: IPsum Malicious IPs [threat_intel]\n",
-      "   • feodotracker_botnet: Feodo Tracker Botnet C2 [threat_intel]\n",
-      "   • urlhaus_malicious: URLhaus Malicious URLs [threat_intel]\n",
-      "   • spambase_uci: UCI Spambase [spam]\n",
-      "   • xss_payloads: XSS Attack Payloads [web_attack]\n",
-      "   • sql_injection_payloads: SQL Injection Payloads [web_attack]\n",
-      "   • http_csic_requests: HTTP CSIC 2010 Dataset [web_attack]\n",
-      "   • cryptomining_scripts: Cryptomining Script Detection [cryptomining]\n",
-      "   • dga_domains: DGA Domain Detection [dns]\n",
-      "   • ssl_certificates: SSL Certificate Analysis [ssl]\n",
-      "   • system_logs_hdfs: HDFS System Logs [logs]\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Initialize dataset manager\n",
-    "DATASET_DIR = Path.cwd().parent / 'datasets' / 'web_security'\n",
-    "manager = WebSecurityDatasetManager(str(DATASET_DIR))\n",
-    "\n",
-    "# Show available datasets\n",
-    "info = manager.get_available_datasets()\n",
-    "print('📊 Available Security Datasets:')\n",
-    "print(f'   Categories: {info[\"categories\"]}')\n",
-    "print(f'   Total datasets: {len(info[\"configured\"])}')\n",
-    "print(f'   Estimated samples: {info[\"total_configured_samples\"]:,}')\n",
-    "\n",
-    "print('\\n📋 Dataset List:')\n",
-    "for ds_id, ds_info in manager.SECURITY_DATASETS.items():\n",
-    "    print(f'   • {ds_id}: {ds_info[\"name\"]} [{ds_info[\"category\"]}]')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "17800fb7",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "📥 Downloading all security datasets...\n",
-      "   This may take 5-10 minutes on first run.\n",
-      "\n",
-      "\n",
-      "📊 Download Results:\n",
-      "   ✅ Successful: 0\n",
-      "   ⏭️ Skipped: 18\n",
-      "   ❌ Failed: 0\n",
-      "\n",
-      "   📈 Total samples available: 1,072,129\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Download all datasets\n",
-    "print('📥 Downloading all security datasets...')\n",
-    "print('   This may take 5-10 minutes on first run.\\n')\n",
-    "\n",
-    "async def download_all():\n",
-    "    return await manager.download_all_datasets(force=False)\n",
-    "\n",
-    "results = asyncio.run(download_all())\n",
-    "\n",
-    "print('\\n📊 Download Results:')\n",
-    "print(f'   ✅ Successful: {len(results[\"successful\"])}')\n",
-    "print(f'   ⏭️ Skipped: {len(results[\"skipped\"])}')\n",
-    "print(f'   ❌ Failed: {len(results[\"failed\"])}')\n",
-    "print(f'\\n   📈 Total samples available: {results[\"total_samples\"]:,}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "218aa401",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "📁 Downloaded Datasets Summary:\n",
-      "\n",
-      "               Dataset     Category  Samples Synthetic\n",
-      "   url_phishing_kaggle     phishing   450000        No\n",
-      " phishing_websites_uci     phishing    11055        No\n",
-      "   malware_pe_features      malware     4500        No\n",
-      "android_malware_drebin      malware    15000        No\n",
-      "       cicids2017_ddos    intrusion   128000        No\n",
-      "         nsl_kdd_train    intrusion   125973        No\n",
-      "             unsw_nb15    intrusion   175000        No\n",
-      "   ipsum_malicious_ips threat_intel    25000        No\n",
-      "   feodotracker_botnet threat_intel     5000        No\n",
-      "     urlhaus_malicious threat_intel    10000        No\n",
-      "          spambase_uci         spam     4601        No\n",
-      "          xss_payloads   web_attack     5000        No\n",
-      "sql_injection_payloads   web_attack     3000        No\n",
-      "    http_csic_requests   web_attack    36000        No\n",
-      "  cryptomining_scripts cryptomining     5000        No\n",
-      "           dga_domains          dns    50000        No\n",
-      "      ssl_certificates          ssl     8000        No\n",
-      "      system_logs_hdfs         logs    11000        No\n",
-      "\n",
-      "📊 Total: 1,072,129 samples across 18 datasets\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Verify downloaded datasets\n",
-    "print('\\n📁 Downloaded Datasets Summary:\\n')\n",
-    "\n",
-    "import pandas as pd\n",
-    "\n",
-    "summary_data = []\n",
-    "for ds_id, info in manager.downloaded_datasets.items():\n",
-    "    samples = info.get('actual_samples', info.get('samples', 0))\n",
-    "    category = info.get('category', 'unknown')\n",
-    "    synthetic = 'Yes' if info.get('synthetic') else 'No'\n",
-    "    \n",
-    "    summary_data.append({\n",
-    "        'Dataset': ds_id,\n",
-    "        'Category': category,\n",
-    "        'Samples': samples,\n",
-    "        'Synthetic': synthetic\n",
-    "    })\n",
-    "\n",
-    "summary_df = pd.DataFrame(summary_data)\n",
-    "print(summary_df.to_string(index=False))\n",
-    "\n",
-    "print(f'\\n📊 Total: {summary_df[\"Samples\"].sum():,} samples across {len(summary_df)} datasets')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "9ccb78f2",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "🔍 Data Quality Check:\n",
-      "\n",
-      "\n",
-      "✅ Dataset preparation complete!\n",
-      "\n",
-      "🚀 You can now run the training notebooks.\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Quick data quality check\n",
-    "print('🔍 Data Quality Check:\\n')\n",
-    "\n",
-    "async def check_quality():\n",
-    "    for ds_id in list(manager.downloaded_datasets.keys())[:5]:  # Check first 5\n",
-    "        df = await manager.load_dataset(ds_id)\n",
-    "        if df is not None:\n",
-    "            null_pct = (df.isnull().sum().sum() / (df.shape[0] * df.shape[1])) * 100\n",
-    "            print(f'   {ds_id}:')\n",
-    "            print(f'      Shape: {df.shape}')\n",
-    "            print(f'      Null %: {null_pct:.2f}%')\n",
-    "            print(f'      Numeric cols: {len(df.select_dtypes(include=[\"number\"]).columns)}')\n",
-    "\n",
-    "asyncio.run(check_quality())\n",
-    "\n",
-    "print('\\n✅ Dataset preparation complete!')\n",
-    "print('\\n🚀 You can now run the training notebooks.')"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.15.0"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

notebooks/02_deep_learning_security.ipynb

@@ -1,856 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "0d580912",
-   "metadata": {},
-   "source": [
-    "# 🧠 Deep Learning Security Models\n",
-    "\n",
-    "## Advanced Neural Networks for Cybersecurity\n",
-    "\n",
-    "This notebook focuses on training **deep learning models** for security classification:\n",
-    "\n",
-    "- **Transformer-based Detection** - Attention mechanisms for sequence analysis\n",
-    "- **Convolutional Networks** - Pattern detection in security data\n",
-    "- **LSTM/GRU Networks** - Temporal pattern recognition\n",
-    "- **AutoEncoders** - Anomaly detection via reconstruction error\n",
-    "- **Multi-Task Learning** - Unified model for multiple security domains"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "2a6ddc2d",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "🐍 Current Python: 3.15.0a3 (v3.15.0a3:f1eb0c0b0cd, Dec 16 2025, 08:05:19) [Clang 17.0.0 (clang-1700.6.3.2)]\n",
-      "⚠️ Python 3.15 detected. TensorFlow requires Python 3.9-3.11\n",
-      "   Installing other packages without TensorFlow...\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "  \u001b[1;31merror\u001b[0m: \u001b[1msubprocess-exited-with-error\u001b[0m\n",
-      "  \n",
-      "  \u001b[31m×\u001b[0m \u001b[32minstalling build dependencies for scikit-learn\u001b[0m did not run successfully.\n",
-      "  \u001b[31m│\u001b[0m exit code: \u001b[1;36m1\u001b[0m\n",
-      "  \u001b[31m╰─>\u001b[0m \u001b[31m[81 lines of output]\u001b[0m\n",
-      "  \u001b[31m   \u001b[0m Collecting meson-python<0.19.0,>=0.17.1\n",
-      "  \u001b[31m   \u001b[0m   Using cached meson_python-0.18.0-py3-none-any.whl.metadata (2.8 kB)\n",
-      "  \u001b[31m   \u001b[0m Collecting cython<3.3.0,>=3.1.2\n",
-      "  \u001b[31m   \u001b[0m   Using cached cython-3.2.4-cp39-abi3-macosx_10_9_x86_64.whl.metadata (7.5 kB)\n",
-      "  \u001b[31m   \u001b[0m Collecting numpy<2.4.0,>=2\n",
-      "  \u001b[31m   \u001b[0m   Using cached numpy-2.3.5.tar.gz (20.6 MB)\n",
-      "  \u001b[31m   \u001b[0m   Installing build dependencies: started\n",
-      "  \u001b[31m   \u001b[0m   Installing build dependencies: finished with status 'done'\n",
-      "  \u001b[31m   \u001b[0m   Getting requirements to build wheel: started\n",
-      "  \u001b[31m   \u001b[0m   Getting requirements to build wheel: finished with status 'done'\n",
-      "  \u001b[31m   \u001b[0m   Installing backend dependencies: started\n",
-      "  \u001b[31m   \u001b[0m   Installing backend dependencies: finished with status 'done'\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): started\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): still running...\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): finished with status 'done'\n",
-      "  \u001b[31m   \u001b[0m \u001b[33mWARNING: Retrying (Retry(total=4, connect=None, read=None, redirect=None, status=None)) after connection broken by 'ProtocolError('Connection aborted.', ConnectionResetError(54, 'Connection reset by peer'))': /simple/scipy/\u001b[0m\u001b[33m\n",
-      "  \u001b[31m   \u001b[0m \u001b[0mCollecting scipy<1.17.0,>=1.10.0\n",
-      "  \u001b[31m   \u001b[0m   Using cached scipy-1.16.3.tar.gz (30.6 MB)\n",
-      "  \u001b[31m   \u001b[0m   Installing build dependencies: started\n",
-      "  \u001b[31m   \u001b[0m   Installing build dependencies: finished with status 'done'\n",
-      "  \u001b[31m   \u001b[0m   Getting requirements to build wheel: started\n",
-      "  \u001b[31m   \u001b[0m   Getting requirements to build wheel: finished with status 'done'\n",
-      "  \u001b[31m   \u001b[0m   Installing backend dependencies: started\n",
-      "  \u001b[31m   \u001b[0m   Installing backend dependencies: finished with status 'done'\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): started\n",
-      "  \u001b[31m   \u001b[0m   Preparing metadata (pyproject.toml): finished with status 'error'\n",
-      "  \u001b[31m   \u001b[0m   \u001b[1;31merror\u001b[0m: \u001b[1msubprocess-exited-with-error\u001b[0m\n",
-      "  \u001b[31m   \u001b[0m \n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m×\u001b[0m \u001b[32mPreparing metadata \u001b[0m\u001b[1;32m(\u001b[0m\u001b[32mpyproject.toml\u001b[0m\u001b[1;32m)\u001b[0m did not run successfully.\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m│\u001b[0m exit code: \u001b[1;36m1\u001b[0m\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m╰─>\u001b[0m \u001b[31m[23 lines of output]\u001b[0m\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m \u001b[36m\u001b[1m+ meson setup /private/var/folders/3f/7mz66tl156s4w_xt0pqq7bwc0000gn/T/pip-install-iutka178/scipy_bdc2fda37451456fa9ccb51189c51876 /private/var/folders/3f/7mz66tl156s4w_xt0pqq7bwc0000gn/T/pip-install-iutka178/scipy_bdc2fda37451456fa9ccb51189c51876/.mesonpy-3_laly6u -Dbuildtype=release -Db_ndebug=if-release -Db_vscrt=md --native-file=/private/var/folders/3f/7mz66tl156s4w_xt0pqq7bwc0000gn/T/pip-install-iutka178/scipy_bdc2fda37451456fa9ccb51189c51876/.mesonpy-3_laly6u/meson-python-native-file.ini\u001b[0m\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m The Meson build system\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m Version: 1.10.1\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m Source dir: /private/var/folders/3f/7mz66tl156s4w_xt0pqq7bwc0000gn/T/pip-install-iutka178/scipy_bdc2fda37451456fa9ccb51189c51876\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m Build dir: /private/var/folders/3f/7mz66tl156s4w_xt0pqq7bwc0000gn/T/pip-install-iutka178/scipy_bdc2fda37451456fa9ccb51189c51876/.mesonpy-3_laly6u\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m Build type: native build\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m Project name: scipy\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m Project version: 1.16.3\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m C compiler for the host machine: cc (clang 14.0.3 \"Apple clang version 14.0.3 (clang-1403.0.22.14.1)\")\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m C linker for the host machine: cc ld64 857.1\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m C++ compiler for the host machine: c++ (clang 14.0.3 \"Apple clang version 14.0.3 (clang-1403.0.22.14.1)\")\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m C++ linker for the host machine: c++ ld64 857.1\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m Cython compiler for the host machine: cython (cython 3.1.8)\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m Host machine cpu family: x86_64\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m Host machine cpu: x86_64\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m Program python found: YES (/Users/Dadaicon/Documents/GitHub/Real-Time-cyber-Forge-Agentic-AI/.venv/bin/python)\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m Found pkg-config: YES (/usr/local/bin/pkg-config) 2.5.1\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m Run-time dependency python found: YES 3.15\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m Program cython found: YES (/private/var/folders/3f/7mz66tl156s4w_xt0pqq7bwc0000gn/T/pip-build-env-dno50jhk/overlay/bin/cython)\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m ../meson.build:53:4: ERROR: Problem encountered: SciPy requires clang >= 15.0\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m A full log can be found at /private/var/folders/3f/7mz66tl156s4w_xt0pqq7bwc0000gn/T/pip-install-iutka178/scipy_bdc2fda37451456fa9ccb51189c51876/.mesonpy-3_laly6u/meson-logs/meson-log.txt\n",
-      "  \u001b[31m   \u001b[0m   \u001b[31m   \u001b[0m \u001b[31m[end of output]\u001b[0m\n",
-      "  \u001b[31m   \u001b[0m \n",
-      "  \u001b[31m   \u001b[0m   \u001b[1;35mnote\u001b[0m: This error originates from a subprocess, and is likely not a problem with pip.\n",
-      "  \u001b[31m   \u001b[0m \u001b[1;31merror\u001b[0m: \u001b[1mmetadata-generation-failed\u001b[0m\n",
-      "  \u001b[31m   \u001b[0m \n",
-      "  \u001b[31m   \u001b[0m \u001b[31m×\u001b[0m Encountered error while generating package metadata.\n",
-      "  \u001b[31m   \u001b[0m \u001b[31m╰─>\u001b[0m scipy\n",
-      "  \u001b[31m   \u001b[0m \n",
-      "  \u001b[31m   \u001b[0m \u001b[1;35mnote\u001b[0m: This is an issue with the package mentioned above, not pip.\n",
-      "  \u001b[31m   \u001b[0m \u001b[1;36mhint\u001b[0m: See above for details.\n",
-      "  \u001b[31m   \u001b[0m \u001b[31m[end of output]\u001b[0m\n",
-      "  \n",
-      "  \u001b[1;35mnote\u001b[0m: This error originates from a subprocess, and is likely not a problem with pip.\n",
-      "\u001b[31mERROR: Failed to build 'scikit-learn' when installing build dependencies for scikit-learn\u001b[0m\u001b[31m\n",
-      "\u001b[0mNote: you may need to restart the kernel to use updated packages.\n",
-      "✅ Packages installed (without TensorFlow)\n",
-      "   Please switch to Python 3.9-3.11 kernel to use deep learning models\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Install required packages using pip magic (ensures correct kernel environment)\n",
-    "# Note: TensorFlow requires Python 3.9-3.11. If you see errors, switch to venv kernel or use Python 3.11\n",
-    "\n",
-    "import sys\n",
-    "print(f'🐍 Current Python: {sys.version}')\n",
-    "\n",
-    "# Check Python version\n",
-    "major, minor = sys.version_info[:2]\n",
-    "if major == 3 and 9 <= minor <= 11:\n",
-    "    %pip install -q tensorflow scikit-learn pandas numpy matplotlib seaborn imbalanced-learn nest_asyncio tqdm\n",
-    "    print('✅ All packages installed including TensorFlow')\n",
-    "else:\n",
-    "    print(f'⚠️ Python {major}.{minor} detected. TensorFlow requires Python 3.9-3.11')\n",
-    "    print('   Installing other packages without TensorFlow...')\n",
-    "    %pip install -q scikit-learn pandas numpy matplotlib seaborn imbalanced-learn nest_asyncio tqdm\n",
-    "    print('✅ Packages installed (without TensorFlow)')\n",
-    "    print('   Please switch to Python 3.9-3.11 kernel to use deep learning models')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "f1af9c6b",
-   "metadata": {},
-   "outputs": [
-    {
-     "ename": "ModuleNotFoundError",
-     "evalue": "No module named 'matplotlib'",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
-      "\u001b[31mModuleNotFoundError\u001b[39m                       Traceback (most recent call last)",
-      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[3]\u001b[39m\u001b[32m, line 7\u001b[39m\n\u001b[32m      5\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnumpy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnp\u001b[39;00m\n\u001b[32m      6\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpandas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpd\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m7\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mmatplotlib\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mpyplot\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mplt\u001b[39;00m\n\u001b[32m      8\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mseaborn\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01msns\u001b[39;00m\n\u001b[32m      9\u001b[39m \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mpathlib\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mimport\u001b[39;00m Path\n",
-      "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'matplotlib'"
-     ]
-    }
-   ],
-   "source": [
-    "import os\n",
-    "import sys\n",
-    "import asyncio\n",
-    "import warnings\n",
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "import matplotlib.pyplot as plt\n",
-    "import seaborn as sns\n",
-    "from pathlib import Path\n",
-    "from datetime import datetime\n",
-    "import json\n",
-    "import joblib\n",
-    "\n",
-    "# ML\n",
-    "from sklearn.model_selection import train_test_split, StratifiedKFold\n",
-    "from sklearn.preprocessing import StandardScaler, LabelEncoder\n",
-    "from sklearn.metrics import (\n",
-    "    classification_report, confusion_matrix, roc_auc_score,\n",
-    "    roc_curve, precision_recall_curve, f1_score, accuracy_score\n",
-    ")\n",
-    "\n",
-    "# Deep Learning\n",
-    "import tensorflow as tf\n",
-    "from tensorflow.keras.models import Model, Sequential\n",
-    "from tensorflow.keras.layers import (\n",
-    "    Input, Dense, Dropout, BatchNormalization, \n",
-    "    Conv1D, MaxPooling1D, GlobalMaxPooling1D, Flatten,\n",
-    "    LSTM, GRU, Bidirectional, Attention, MultiHeadAttention,\n",
-    "    Concatenate, Add, LayerNormalization, Embedding\n",
-    ")\n",
-    "from tensorflow.keras.optimizers import Adam, AdamW\n",
-    "from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint\n",
-    "from tensorflow.keras.regularizers import l1_l2\n",
-    "\n",
-    "from imblearn.over_sampling import SMOTE\n",
-    "\n",
-    "# Config\n",
-    "warnings.filterwarnings('ignore')\n",
-    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n",
-    "np.random.seed(42)\n",
-    "tf.random.set_seed(42)\n",
-    "\n",
-    "# Add path\n",
-    "sys.path.insert(0, str(Path.cwd().parent / 'app' / 'services'))\n",
-    "\n",
-    "try:\n",
-    "    import nest_asyncio\n",
-    "    nest_asyncio.apply()\n",
-    "except:\n",
-    "    pass\n",
-    "\n",
-    "plt.style.use('dark_background')\n",
-    "\n",
-    "print('🚀 Environment ready!')\n",
-    "print(f'   TensorFlow: {tf.__version__}')\n",
-    "print(f'   GPU available: {len(tf.config.list_physical_devices(\"GPU\")) > 0}')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7962e94f",
-   "metadata": {},
-   "source": [
-    "## 📥 Load Security Datasets"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "65ed96aa",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from web_security_datasets import WebSecurityDatasetManager\n",
-    "\n",
-    "DATASET_DIR = Path.cwd().parent / 'datasets' / 'web_security'\n",
-    "manager = WebSecurityDatasetManager(str(DATASET_DIR))\n",
-    "\n",
-    "# Download if needed\n",
-    "async def ensure_datasets():\n",
-    "    if len(manager.downloaded_datasets) < 5:\n",
-    "        print('📥 Downloading datasets...')\n",
-    "        await manager.download_all_datasets()\n",
-    "    return manager.downloaded_datasets\n",
-    "\n",
-    "datasets = asyncio.run(ensure_datasets())\n",
-    "print(f'\\n✅ {len(datasets)} datasets available')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "369d8983",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Load combined dataset for multi-domain training\n",
-    "async def load_combined(max_per_ds: int = 20000):\n",
-    "    return await manager.get_combined_dataset(max_samples_per_dataset=max_per_ds)\n",
-    "\n",
-    "combined_df = asyncio.run(load_combined())\n",
-    "print(f'📊 Combined dataset: {len(combined_df):,} samples')\n",
-    "print(f'   Features: {combined_df.shape[1]}')\n",
-    "print(f'   Categories: {combined_df[\"_category\"].value_counts().to_dict()}')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "3fc0c63d",
-   "metadata": {},
-   "source": [
-    "## 🏗️ Deep Learning Architectures"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "f834f8a9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class DeepSecurityModels:\n",
-    "    \"\"\"Advanced deep learning models for security classification.\"\"\"\n",
-    "    \n",
-    "    @staticmethod\n",
-    "    def transformer_block(x, embed_dim, num_heads, ff_dim, dropout=0.1):\n",
-    "        \"\"\"Transformer encoder block.\"\"\"\n",
-    "        # Multi-head attention\n",
-    "        attn_output = MultiHeadAttention(\n",
-    "            key_dim=embed_dim, num_heads=num_heads, dropout=dropout\n",
-    "        )(x, x)\n",
-    "        x1 = LayerNormalization(epsilon=1e-6)(x + attn_output)\n",
-    "        \n",
-    "        # Feed-forward\n",
-    "        ff = Dense(ff_dim, activation='relu')(x1)\n",
-    "        ff = Dropout(dropout)(ff)\n",
-    "        ff = Dense(embed_dim)(ff)\n",
-    "        return LayerNormalization(epsilon=1e-6)(x1 + ff)\n",
-    "    \n",
-    "    @staticmethod\n",
-    "    def create_transformer_classifier(input_dim: int, \n",
-    "                                       embed_dim: int = 64,\n",
-    "                                       num_heads: int = 4,\n",
-    "                                       ff_dim: int = 128,\n",
-    "                                       num_blocks: int = 2) -> Model:\n",
-    "        \"\"\"Transformer-based security classifier.\"\"\"\n",
-    "        inputs = Input(shape=(input_dim,))\n",
-    "        \n",
-    "        # Project to embedding dimension\n",
-    "        x = Dense(embed_dim)(inputs)\n",
-    "        x = tf.expand_dims(x, axis=1)  # Add sequence dimension\n",
-    "        \n",
-    "        # Stack transformer blocks\n",
-    "        for _ in range(num_blocks):\n",
-    "            x = DeepSecurityModels.transformer_block(x, embed_dim, num_heads, ff_dim)\n",
-    "        \n",
-    "        # Global pooling and classification\n",
-    "        x = tf.squeeze(x, axis=1)\n",
-    "        x = Dropout(0.2)(x)\n",
-    "        x = Dense(32, activation='relu')(x)\n",
-    "        outputs = Dense(1, activation='sigmoid')(x)\n",
-    "        \n",
-    "        model = Model(inputs, outputs, name='transformer_classifier')\n",
-    "        model.compile(\n",
-    "            optimizer=AdamW(learning_rate=1e-4),\n",
-    "            loss='binary_crossentropy',\n",
-    "            metrics=['accuracy', 'AUC']\n",
-    "        )\n",
-    "        return model\n",
-    "    \n",
-    "    @staticmethod\n",
-    "    def create_cnn_classifier(input_dim: int) -> Model:\n",
-    "        \"\"\"1D CNN for security pattern detection.\"\"\"\n",
-    "        inputs = Input(shape=(input_dim, 1))\n",
-    "        \n",
-    "        # Conv blocks\n",
-    "        x = Conv1D(64, 3, activation='relu', padding='same')(inputs)\n",
-    "        x = BatchNormalization()(x)\n",
-    "        x = MaxPooling1D(2)(x)\n",
-    "        \n",
-    "        x = Conv1D(128, 3, activation='relu', padding='same')(x)\n",
-    "        x = BatchNormalization()(x)\n",
-    "        x = MaxPooling1D(2)(x)\n",
-    "        \n",
-    "        x = Conv1D(256, 3, activation='relu', padding='same')(x)\n",
-    "        x = GlobalMaxPooling1D()(x)\n",
-    "        \n",
-    "        # Classification head\n",
-    "        x = Dense(64, activation='relu')(x)\n",
-    "        x = Dropout(0.3)(x)\n",
-    "        outputs = Dense(1, activation='sigmoid')(x)\n",
-    "        \n",
-    "        model = Model(inputs, outputs, name='cnn_classifier')\n",
-    "        model.compile(\n",
-    "            optimizer=Adam(learning_rate=1e-3),\n",
-    "            loss='binary_crossentropy',\n",
-    "            metrics=['accuracy', 'AUC']\n",
-    "        )\n",
-    "        return model\n",
-    "    \n",
-    "    @staticmethod\n",
-    "    def create_lstm_classifier(input_dim: int) -> Model:\n",
-    "        \"\"\"Bidirectional LSTM for sequence analysis.\"\"\"\n",
-    "        inputs = Input(shape=(input_dim, 1))\n",
-    "        \n",
-    "        x = Bidirectional(LSTM(64, return_sequences=True))(inputs)\n",
-    "        x = Dropout(0.3)(x)\n",
-    "        x = Bidirectional(LSTM(32))(x)\n",
-    "        x = Dropout(0.3)(x)\n",
-    "        \n",
-    "        x = Dense(32, activation='relu')(x)\n",
-    "        outputs = Dense(1, activation='sigmoid')(x)\n",
-    "        \n",
-    "        model = Model(inputs, outputs, name='lstm_classifier')\n",
-    "        model.compile(\n",
-    "            optimizer=Adam(learning_rate=1e-3),\n",
-    "            loss='binary_crossentropy',\n",
-    "            metrics=['accuracy', 'AUC']\n",
-    "        )\n",
-    "        return model\n",
-    "    \n",
-    "    @staticmethod\n",
-    "    def create_autoencoder(input_dim: int, encoding_dim: int = 32) -> tuple:\n",
-    "        \"\"\"Autoencoder for anomaly detection.\"\"\"\n",
-    "        # Encoder\n",
-    "        inputs = Input(shape=(input_dim,))\n",
-    "        x = Dense(128, activation='relu')(inputs)\n",
-    "        x = BatchNormalization()(x)\n",
-    "        x = Dense(64, activation='relu')(x)\n",
-    "        x = BatchNormalization()(x)\n",
-    "        encoded = Dense(encoding_dim, activation='relu', name='encoding')(x)\n",
-    "        \n",
-    "        # Decoder\n",
-    "        x = Dense(64, activation='relu')(encoded)\n",
-    "        x = BatchNormalization()(x)\n",
-    "        x = Dense(128, activation='relu')(x)\n",
-    "        x = BatchNormalization()(x)\n",
-    "        decoded = Dense(input_dim, activation='linear')(x)\n",
-    "        \n",
-    "        autoencoder = Model(inputs, decoded, name='autoencoder')\n",
-    "        autoencoder.compile(optimizer=Adam(1e-3), loss='mse')\n",
-    "        \n",
-    "        encoder = Model(inputs, encoded, name='encoder')\n",
-    "        \n",
-    "        return autoencoder, encoder\n",
-    "    \n",
-    "    @staticmethod\n",
-    "    def create_multi_task_model(input_dim: int, num_tasks: int = 3) -> Model:\n",
-    "        \"\"\"Multi-task model for multiple security domains.\"\"\"\n",
-    "        inputs = Input(shape=(input_dim,))\n",
-    "        \n",
-    "        # Shared layers\n",
-    "        shared = Dense(256, activation='relu')(inputs)\n",
-    "        shared = BatchNormalization()(shared)\n",
-    "        shared = Dropout(0.3)(shared)\n",
-    "        shared = Dense(128, activation='relu')(shared)\n",
-    "        shared = BatchNormalization()(shared)\n",
-    "        shared = Dropout(0.2)(shared)\n",
-    "        shared = Dense(64, activation='relu')(shared)\n",
-    "        \n",
-    "        # Task-specific heads\n",
-    "        outputs = []\n",
-    "        task_names = ['phishing', 'malware', 'intrusion']\n",
-    "        for i in range(min(num_tasks, len(task_names))):\n",
-    "            task_layer = Dense(32, activation='relu', name=f'{task_names[i]}_hidden')(shared)\n",
-    "            task_output = Dense(1, activation='sigmoid', name=f'{task_names[i]}_output')(task_layer)\n",
-    "            outputs.append(task_output)\n",
-    "        \n",
-    "        model = Model(inputs, outputs, name='multi_task_security')\n",
-    "        model.compile(\n",
-    "            optimizer=Adam(1e-3),\n",
-    "            loss={f'{task_names[i]}_output': 'binary_crossentropy' for i in range(len(outputs))},\n",
-    "            metrics=['accuracy']\n",
-    "        )\n",
-    "        return model\n",
-    "\n",
-    "print('✅ Deep learning architectures defined')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "abdaab25",
-   "metadata": {},
-   "source": [
-    "## 🎯 Training Pipeline"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "673c6e4b",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def prepare_data_for_training(df: pd.DataFrame, max_features: int = 50) -> tuple:\n",
-    "    \"\"\"Prepare data for deep learning training.\"\"\"\n",
-    "    \n",
-    "    # Find target column\n",
-    "    target_candidates = ['is_malicious', 'is_attack', 'is_malware', 'is_spam', \n",
-    "                        'is_dga', 'is_miner', 'label', 'result']\n",
-    "    target_col = None\n",
-    "    for col in target_candidates:\n",
-    "        if col in df.columns:\n",
-    "            target_col = col\n",
-    "            break\n",
-    "    \n",
-    "    if target_col is None:\n",
-    "        # Find binary column\n",
-    "        for col in df.columns:\n",
-    "            if df[col].nunique() == 2 and col not in ['_category', '_dataset_id']:\n",
-    "                target_col = col\n",
-    "                break\n",
-    "    \n",
-    "    if target_col is None:\n",
-    "        raise ValueError('No target column found')\n",
-    "    \n",
-    "    # Select numeric features\n",
-    "    exclude = [target_col, '_category', '_dataset_id', 'source_dataset', 'url', 'payload', 'domain']\n",
-    "    feature_cols = [c for c in df.select_dtypes(include=[np.number]).columns if c not in exclude]\n",
-    "    \n",
-    "    # Limit features\n",
-    "    if len(feature_cols) > max_features:\n",
-    "        feature_cols = feature_cols[:max_features]\n",
-    "    \n",
-    "    X = df[feature_cols].fillna(0).replace([np.inf, -np.inf], 0)\n",
-    "    y = df[target_col].astype(int)\n",
-    "    \n",
-    "    # Scale\n",
-    "    scaler = StandardScaler()\n",
-    "    X_scaled = scaler.fit_transform(X)\n",
-    "    \n",
-    "    return X_scaled, y.values, feature_cols, scaler\n",
-    "\n",
-    "# Prepare data\n",
-    "X, y, features, scaler = prepare_data_for_training(combined_df)\n",
-    "print(f'📊 Data prepared: {X.shape}')\n",
-    "print(f'   Features: {len(features)}')\n",
-    "print(f'   Class balance: {np.bincount(y)}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "9caabf5f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Split and balance data\n",
-    "X_train, X_test, y_train, y_test = train_test_split(\n",
-    "    X, y, test_size=0.2, random_state=42, stratify=y\n",
-    ")\n",
-    "\n",
-    "# Balance training data\n",
-    "try:\n",
-    "    smote = SMOTE(random_state=42)\n",
-    "    X_train_balanced, y_train_balanced = smote.fit_resample(X_train, y_train)\n",
-    "    print(f'✅ After SMOTE: {len(X_train_balanced):,} training samples')\n",
-    "except:\n",
-    "    X_train_balanced, y_train_balanced = X_train, y_train\n",
-    "    print('⚠️ SMOTE skipped')\n",
-    "\n",
-    "print(f'   Train: {len(X_train_balanced):,} | Test: {len(X_test):,}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ccee951f",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Training callbacks\n",
-    "callbacks = [\n",
-    "    EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True),\n",
-    "    ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=5, min_lr=1e-6)\n",
-    "]\n",
-    "\n",
-    "# Train Transformer model\n",
-    "print('🔄 Training Transformer model...')\n",
-    "transformer = DeepSecurityModels.create_transformer_classifier(X.shape[1])\n",
-    "\n",
-    "history_transformer = transformer.fit(\n",
-    "    X_train_balanced, y_train_balanced,\n",
-    "    validation_split=0.2,\n",
-    "    epochs=50,\n",
-    "    batch_size=64,\n",
-    "    callbacks=callbacks,\n",
-    "    verbose=1\n",
-    ")\n",
-    "\n",
-    "transformer_pred = (transformer.predict(X_test, verbose=0) > 0.5).astype(int).flatten()\n",
-    "transformer_auc = roc_auc_score(y_test, transformer.predict(X_test, verbose=0))\n",
-    "print(f'\\n✅ Transformer AUC: {transformer_auc:.4f}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "5d0c55b2",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Train CNN model\n",
-    "print('🔄 Training CNN model...')\n",
-    "\n",
-    "X_train_cnn = X_train_balanced.reshape(-1, X_train_balanced.shape[1], 1)\n",
-    "X_test_cnn = X_test.reshape(-1, X_test.shape[1], 1)\n",
-    "\n",
-    "cnn = DeepSecurityModels.create_cnn_classifier(X.shape[1])\n",
-    "\n",
-    "history_cnn = cnn.fit(\n",
-    "    X_train_cnn, y_train_balanced,\n",
-    "    validation_split=0.2,\n",
-    "    epochs=50,\n",
-    "    batch_size=64,\n",
-    "    callbacks=callbacks,\n",
-    "    verbose=1\n",
-    ")\n",
-    "\n",
-    "cnn_pred = (cnn.predict(X_test_cnn, verbose=0) > 0.5).astype(int).flatten()\n",
-    "cnn_auc = roc_auc_score(y_test, cnn.predict(X_test_cnn, verbose=0))\n",
-    "print(f'\\n✅ CNN AUC: {cnn_auc:.4f}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3299c3c0",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Train LSTM model\n",
-    "print('🔄 Training LSTM model...')\n",
-    "\n",
-    "lstm = DeepSecurityModels.create_lstm_classifier(X.shape[1])\n",
-    "\n",
-    "history_lstm = lstm.fit(\n",
-    "    X_train_cnn, y_train_balanced,  # Same shape as CNN\n",
-    "    validation_split=0.2,\n",
-    "    epochs=30,  # LSTM is slower\n",
-    "    batch_size=64,\n",
-    "    callbacks=callbacks,\n",
-    "    verbose=1\n",
-    ")\n",
-    "\n",
-    "lstm_pred = (lstm.predict(X_test_cnn, verbose=0) > 0.5).astype(int).flatten()\n",
-    "lstm_auc = roc_auc_score(y_test, lstm.predict(X_test_cnn, verbose=0))\n",
-    "print(f'\\n✅ LSTM AUC: {lstm_auc:.4f}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c47177bf",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Train Autoencoder for anomaly detection\n",
-    "print('🔄 Training Autoencoder...')\n",
-    "\n",
-    "# Train only on normal samples\n",
-    "X_normal = X_train_balanced[y_train_balanced == 0]\n",
-    "\n",
-    "autoencoder, encoder = DeepSecurityModels.create_autoencoder(X.shape[1])\n",
-    "\n",
-    "history_ae = autoencoder.fit(\n",
-    "    X_normal, X_normal,\n",
-    "    validation_split=0.2,\n",
-    "    epochs=50,\n",
-    "    batch_size=64,\n",
-    "    callbacks=callbacks,\n",
-    "    verbose=1\n",
-    ")\n",
-    "\n",
-    "# Anomaly scores based on reconstruction error\n",
-    "reconstructions = autoencoder.predict(X_test, verbose=0)\n",
-    "mse = np.mean(np.power(X_test - reconstructions, 2), axis=1)\n",
-    "threshold = np.percentile(mse, 90)  # Top 10% as anomalies\n",
-    "ae_pred = (mse > threshold).astype(int)\n",
-    "ae_auc = roc_auc_score(y_test, mse)\n",
-    "print(f'\\n✅ Autoencoder AUC: {ae_auc:.4f}')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "874d717c",
-   "metadata": {},
-   "source": [
-    "## 📊 Model Comparison"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "58a05f84",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Compare all models\n",
-    "results = {\n",
-    "    'Transformer': {'pred': transformer_pred, 'auc': transformer_auc},\n",
-    "    'CNN': {'pred': cnn_pred, 'auc': cnn_auc},\n",
-    "    'LSTM': {'pred': lstm_pred, 'auc': lstm_auc},\n",
-    "    'Autoencoder': {'pred': ae_pred, 'auc': ae_auc}\n",
-    "}\n",
-    "\n",
-    "# Results table\n",
-    "print('📊 Deep Learning Model Comparison')\n",
-    "print('=' * 60)\n",
-    "print(f'{\"Model\":<15} {\"Accuracy\":<12} {\"F1\":<12} {\"AUC\":<12}')\n",
-    "print('-' * 60)\n",
-    "\n",
-    "for name, res in results.items():\n",
-    "    acc = accuracy_score(y_test, res['pred'])\n",
-    "    f1 = f1_score(y_test, res['pred'])\n",
-    "    print(f'{name:<15} {acc:<12.4f} {f1:<12.4f} {res[\"auc\"]:<12.4f}')\n",
-    "\n",
-    "# Best model\n",
-    "best_model = max(results.items(), key=lambda x: x[1]['auc'])\n",
-    "print(f'\\n🏆 Best Model: {best_model[0]} (AUC: {best_model[1][\"auc\"]:.4f})')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6ffe5221",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Visualize ROC curves\n",
-    "plt.figure(figsize=(10, 8))\n",
-    "\n",
-    "# Get probabilities\n",
-    "probs = {\n",
-    "    'Transformer': transformer.predict(X_test, verbose=0).flatten(),\n",
-    "    'CNN': cnn.predict(X_test_cnn, verbose=0).flatten(),\n",
-    "    'LSTM': lstm.predict(X_test_cnn, verbose=0).flatten(),\n",
-    "    'Autoencoder': mse / mse.max()  # Normalized MSE\n",
-    "}\n",
-    "\n",
-    "colors = ['#4ecdc4', '#ff6b6b', '#ffe66d', '#95e1d3']\n",
-    "for (name, prob), color in zip(probs.items(), colors):\n",
-    "    fpr, tpr, _ = roc_curve(y_test, prob)\n",
-    "    auc = results[name]['auc']\n",
-    "    plt.plot(fpr, tpr, label=f'{name} (AUC = {auc:.4f})', color=color, linewidth=2)\n",
-    "\n",
-    "plt.plot([0, 1], [0, 1], 'k--', alpha=0.5)\n",
-    "plt.xlabel('False Positive Rate', fontsize=12)\n",
-    "plt.ylabel('True Positive Rate', fontsize=12)\n",
-    "plt.title('🎯 Deep Learning ROC Comparison', fontsize=14)\n",
-    "plt.legend(loc='lower right')\n",
-    "plt.grid(True, alpha=0.3)\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ef891827",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Training history visualization\n",
-    "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n",
-    "\n",
-    "histories = [\n",
-    "    ('Transformer', history_transformer),\n",
-    "    ('CNN', history_cnn),\n",
-    "    ('LSTM', history_lstm)\n",
-    "]\n",
-    "\n",
-    "for ax, (name, hist) in zip(axes, histories):\n",
-    "    ax.plot(hist.history['loss'], label='Train Loss')\n",
-    "    ax.plot(hist.history['val_loss'], label='Val Loss')\n",
-    "    ax.set_title(f'{name} Training', color='white')\n",
-    "    ax.set_xlabel('Epoch')\n",
-    "    ax.set_ylabel('Loss')\n",
-    "    ax.legend()\n",
-    "    ax.grid(True, alpha=0.3)\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "7871e52a",
-   "metadata": {},
-   "source": [
-    "## 💾 Save Models"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "0d7755e9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Save trained models\n",
-    "MODELS_DIR = Path.cwd().parent / 'models' / 'deep_learning'\n",
-    "MODELS_DIR.mkdir(parents=True, exist_ok=True)\n",
-    "\n",
-    "print('💾 Saving models...')\n",
-    "\n",
-    "# Save Keras models\n",
-    "transformer.save(MODELS_DIR / 'transformer_security.keras')\n",
-    "cnn.save(MODELS_DIR / 'cnn_security.keras')\n",
-    "lstm.save(MODELS_DIR / 'lstm_security.keras')\n",
-    "autoencoder.save(MODELS_DIR / 'autoencoder_security.keras')\n",
-    "encoder.save(MODELS_DIR / 'encoder_security.keras')\n",
-    "\n",
-    "# Save scaler and config\n",
-    "joblib.dump(scaler, MODELS_DIR / 'scaler.pkl')\n",
-    "joblib.dump(features, MODELS_DIR / 'feature_names.pkl')\n",
-    "\n",
-    "# Save metrics\n",
-    "metrics = {\n",
-    "    name: {'accuracy': float(accuracy_score(y_test, r['pred'])),\n",
-    "           'f1': float(f1_score(y_test, r['pred'])),\n",
-    "           'auc': float(r['auc'])}\n",
-    "    for name, r in results.items()\n",
-    "}\n",
-    "with open(MODELS_DIR / 'metrics.json', 'w') as f:\n",
-    "    json.dump(metrics, f, indent=2)\n",
-    "\n",
-    "print(f'\\n✅ Models saved to {MODELS_DIR}')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "765404ff",
-   "metadata": {},
-   "source": [
-    "## 🎉 Summary\n",
-    "\n",
-    "### Trained Models:\n",
-    "- **Transformer** - Attention-based classifier\n",
-    "- **CNN** - Convolutional pattern detector\n",
-    "- **LSTM** - Sequence analyzer\n",
-    "- **Autoencoder** - Anomaly detector\n",
-    "\n",
-    "### Output Files:\n",
-    "```\n",
-    "models/deep_learning/\n",
-    "├── transformer_security.keras\n",
-    "├── cnn_security.keras\n",
-    "├── lstm_security.keras\n",
-    "├── autoencoder_security.keras\n",
-    "├── encoder_security.keras\n",
-    "├── scaler.pkl\n",
-    "├── feature_names.pkl\n",
-    "└── metrics.json\n",
-    "```\n",
-    "\n",
-    "These models are ready for integration with the Agentic AI security system!"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.15.0a3"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

notebooks/README.md

@@ -1,141 +0,0 @@
-# ML Notebooks Execution Guide
-
-This directory contains machine learning notebooks for the Cyber Forge AI platform. Follow this guide to run the notebooks in the correct order for optimal results.
-
-## 📋 Prerequisites
-
-Before running any notebooks, ensure you have:
-
-1. **Python Environment**: Python 3.9+ installed
-2. **Dependencies**: Install all required packages:
-   ```bash
-   cd ../
-   pip install -r requirements.txt
-   ```
-3. **Jupyter**: Install Jupyter Notebook or JupyterLab:
-   ```bash
-   pip install jupyter jupyterlab
-   ```
-
-## 🎯 Execution Order
-
-Run the notebooks in this specific order to ensure proper model training and dependencies:
-
-### 1. **Basic AI Agent Training** 📚
-**File**: `ai_agent_training.py`
-**Purpose**: Initial AI agent setup and basic training
-**Runtime**: ~10-15 minutes
-**Description**: 
-- Sets up the foundational AI agent
-- Installs core dependencies programmatically
-- Provides basic communication and cybersecurity skills
-- **RUN THIS FIRST** - Required for other notebooks
-
-```bash
-cd ml-services/notebooks
-python ai_agent_training.py
-```
-
-### 2. **Advanced Cybersecurity ML Training** 🛡️
-**File**: `advanced_cybersecurity_ml_training.ipynb`
-**Purpose**: Comprehensive ML model training for threat detection
-**Runtime**: ~30-45 minutes
-**Description**:
-- Data preparation and feature engineering
-- Multiple ML model training (Random Forest, XGBoost, Neural Networks)
-- Model evaluation and comparison
-- Production model deployment preparation
-
-```bash
-jupyter notebook advanced_cybersecurity_ml_training.ipynb
-```
-
-### 3. **Network Security Analysis** 🌐
-**File**: `network_security_analysis.ipynb`
-**Purpose**: Network-specific security analysis and monitoring
-**Runtime**: ~20-30 minutes
-**Description**:
-- Network traffic analysis
-- Intrusion detection model training
-- Port scanning detection
-- Network anomaly detection
-
-```bash
-jupyter notebook network_security_analysis.ipynb
-```
-
-### 4. **Comprehensive AI Agent Training** 🤖
-**File**: `ai_agent_comprehensive_training.ipynb`
-**Purpose**: Advanced AI agent with full capabilities
-**Runtime**: ~45-60 minutes
-**Description**:
-- Enhanced communication skills
-- Web scraping and threat intelligence
-- Real-time monitoring capabilities
-- Natural language processing for security analysis
-- **RUN LAST** - Integrates all previous models
-
-```bash
-jupyter notebook ai_agent_comprehensive_training.ipynb
-```
-
-## 📊 Expected Outputs
-
-After running all notebooks, you should have:
-
-1. **Trained Models**: Saved in `../models/` directory
-2. **Performance Metrics**: Evaluation reports and visualizations
-3. **AI Agent**: Fully trained agent ready for deployment
-4. **Configuration Files**: Model configs for production use
-
-## 🔧 Troubleshooting
-
-### Common Issues:
-
-**Memory Errors**: 
-- Reduce batch size in deep learning models
-- Close other applications to free RAM
-- Consider using smaller datasets for testing
-
-**Package Installation Failures**:
-- Update pip: `pip install --upgrade pip`
-- Use conda if pip fails: `conda install <package>`
-- Check Python version compatibility
-
-**CUDA/GPU Issues**:
-- For TensorFlow GPU: Install CUDA 11.8+ and cuDNN
-- For CPU-only: Models will run slower but still work
-- Check GPU availability: `tensorflow.test.is_gpu_available()`
-
-**Data Download Issues**:
-- Ensure internet connection for Kaggle datasets
-- Set up Kaggle API credentials if needed
-- Some notebooks include fallback synthetic data generation
-
-## 📝 Notes
-
-- **First Run**: Initial execution takes longer due to package installation and data downloads
-- **Subsequent Runs**: Much faster as dependencies are cached
-- **Customization**: Modify hyperparameters in notebooks for different results
-- **Production**: Use the saved models in the main application
-
-## 🎯 Next Steps
-
-After completing all notebooks:
-
-1. **Deploy Models**: Copy trained models to production environment
-2. **Integration**: Connect models with the desktop application
-3. **Monitoring**: Set up model performance monitoring
-4. **Updates**: Retrain models with new data periodically
-
-## 🆘 Support
-
-If you encounter issues:
-1. Check the troubleshooting section above
-2. Verify all prerequisites are met
-3. Review notebook outputs for specific error messages
-4. Create an issue in the repository with error details
-
----
-
-**Happy Training! 🚀**

notebooks/agentic_security_training.ipynb

@@ -1,1287 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "b8f03026",
-   "metadata": {},
-   "source": [
-    "# 🛡️ Advanced Agentic AI Security Training\n",
-    "\n",
-    "## Real-Time Cyber Forge - High-Capability Security Models\n",
-    "\n",
-    "This notebook trains production-grade AI models for the Agentic AI security system with:\n",
-    "\n",
-    "1. **Real-World Datasets** - Downloads from multiple security intelligence sources\n",
-    "2. **Multi-Domain Detection** - Phishing, Malware, Intrusion, XSS, SQLi, DGA\n",
-    "3. **Deep Learning Models** - Neural networks for complex pattern recognition\n",
-    "4. **Ensemble Systems** - Combined models for high accuracy\n",
-    "5. **Real-Time Inference** - Optimized for production deployment\n",
-    "\n",
-    "---\n",
-    "\n",
-    "**Author:** Cyber Forge AI Team  \n",
-    "**Version:** 3.0 - Agentic AI Edition  \n",
-    "**Last Updated:** 2025"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "bb02143c",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 🔧 System Setup and Package Installation\n",
-    "import subprocess\n",
-    "import sys\n",
-    "\n",
-    "def install_packages():\n",
-    "    packages = [\n",
-    "        'pandas>=2.0.0',\n",
-    "        'numpy>=1.24.0',\n",
-    "        'scikit-learn>=1.3.0',\n",
-    "        'tensorflow>=2.13.0',\n",
-    "        'xgboost>=2.0.0',\n",
-    "        'imbalanced-learn>=0.11.0',\n",
-    "        'matplotlib>=3.7.0',\n",
-    "        'seaborn>=0.12.0',\n",
-    "        'aiohttp>=3.8.0',\n",
-    "        'certifi',\n",
-    "        'joblib>=1.3.0',\n",
-    "        'tqdm>=4.65.0',\n",
-    "    ]\n",
-    "    \n",
-    "    for pkg in packages:\n",
-    "        try:\n",
-    "            subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', pkg])\n",
-    "        except Exception as e:\n",
-    "            print(f'Warning: {pkg} - {e}')\n",
-    "    \n",
-    "    print('✅ Packages ready')\n",
-    "\n",
-    "install_packages()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "41d3fd54",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# 📦 Import Libraries\n",
-    "import os\n",
-    "import sys\n",
-    "import asyncio\n",
-    "import warnings\n",
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "import matplotlib.pyplot as plt\n",
-    "import seaborn as sns\n",
-    "from datetime import datetime\n",
-    "from pathlib import Path\n",
-    "import json\n",
-    "import joblib\n",
-    "from tqdm import tqdm\n",
-    "\n",
-    "# Machine Learning\n",
-    "from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold\n",
-    "from sklearn.preprocessing import StandardScaler, LabelEncoder, MinMaxScaler\n",
-    "from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier\n",
-    "from sklearn.linear_model import LogisticRegression\n",
-    "from sklearn.metrics import (\n",
-    "    classification_report, confusion_matrix, roc_auc_score, \n",
-    "    roc_curve, precision_recall_curve, f1_score, accuracy_score,\n",
-    "    precision_score, recall_score\n",
-    ")\n",
-    "from sklearn.feature_selection import SelectKBest, f_classif, mutual_info_classif\n",
-    "\n",
-    "# Deep Learning\n",
-    "import tensorflow as tf\n",
-    "from tensorflow.keras.models import Sequential, Model\n",
-    "from tensorflow.keras.layers import (\n",
-    "    Dense, Dropout, BatchNormalization, Input, \n",
-    "    Conv1D, MaxPooling1D, Flatten, LSTM, GRU,\n",
-    "    Attention, Concatenate, Embedding\n",
-    ")\n",
-    "from tensorflow.keras.optimizers import Adam\n",
-    "from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint\n",
-    "from tensorflow.keras.regularizers import l2\n",
-    "\n",
-    "# Advanced ML\n",
-    "import xgboost as xgb\n",
-    "from imblearn.over_sampling import SMOTE, ADASYN\n",
-    "from imblearn.under_sampling import RandomUnderSampler\n",
-    "from imblearn.combine import SMOTETomek\n",
-    "\n",
-    "# Configuration\n",
-    "warnings.filterwarnings('ignore')\n",
-    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n",
-    "np.random.seed(42)\n",
-    "tf.random.set_seed(42)\n",
-    "\n",
-    "# Add project path\n",
-    "sys.path.insert(0, str(Path.cwd().parent / 'app' / 'services'))\n",
-    "\n",
-    "# Visualization style\n",
-    "plt.style.use('dark_background')\n",
-    "sns.set_palette('viridis')\n",
-    "\n",
-    "print('🚀 Libraries loaded successfully!')\n",
-    "print(f'   TensorFlow: {tf.__version__}')\n",
-    "print(f'   Pandas: {pd.__version__}')\n",
-    "print(f'   NumPy: {np.__version__}')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "75e3575e",
-   "metadata": {},
-   "source": [
-    "## 📥 Section 1: Download Advanced Security Datasets\n",
-    "\n",
-    "Download real-world web security datasets from multiple sources including:\n",
-    "- Malicious URL databases\n",
-    "- Phishing detection datasets  \n",
-    "- Network intrusion (NSL-KDD, CICIDS)\n",
-    "- Threat intelligence feeds\n",
-    "- Web attack payloads (XSS, SQLi)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "15f87f43",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Import our advanced dataset manager\n",
-    "from web_security_datasets import WebSecurityDatasetManager\n",
-    "\n",
-    "# Initialize dataset manager\n",
-    "DATASET_DIR = Path.cwd().parent / 'datasets' / 'web_security'\n",
-    "dataset_manager = WebSecurityDatasetManager(str(DATASET_DIR))\n",
-    "\n",
-    "print('📊 Available Dataset Categories:')\n",
-    "info = dataset_manager.get_available_datasets()\n",
-    "print(f'   Categories: {info[\"categories\"]}')\n",
-    "print(f'   Configured datasets: {len(info[\"configured\"])}')\n",
-    "print(f'   Total samples available: {info[\"total_configured_samples\"]:,}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "779bc1a4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Download all security datasets\n",
-    "print('📥 Downloading advanced web security datasets...')\n",
-    "print('   This may take a few minutes on first run.\\n')\n",
-    "\n",
-    "# Run async download\n",
-    "async def download_datasets():\n",
-    "    results = await dataset_manager.download_all_datasets(force=False)\n",
-    "    return results\n",
-    "\n",
-    "# For Jupyter notebooks\n",
-    "try:\n",
-    "    # Check if we're in an async context\n",
-    "    loop = asyncio.get_event_loop()\n",
-    "    if loop.is_running():\n",
-    "        import nest_asyncio\n",
-    "        nest_asyncio.apply()\n",
-    "        download_results = loop.run_until_complete(download_datasets())\n",
-    "    else:\n",
-    "        download_results = asyncio.run(download_datasets())\n",
-    "except:\n",
-    "    download_results = asyncio.run(download_datasets())\n",
-    "\n",
-    "print('\\n📊 Download Summary:')\n",
-    "print(f'   ✅ Successful: {len(download_results[\"successful\"])}')\n",
-    "print(f'   ⏭️ Skipped (already exists): {len(download_results[\"skipped\"])}')\n",
-    "print(f'   ❌ Failed: {len(download_results[\"failed\"])}')\n",
-    "print(f'   📈 Total samples: {download_results[\"total_samples\"]:,}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "33e740c9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# List downloaded datasets\n",
-    "print('\\n📁 Downloaded Datasets:\\n')\n",
-    "for dataset_id, info in dataset_manager.downloaded_datasets.items():\n",
-    "    samples = info.get('actual_samples', info.get('samples', 'N/A'))\n",
-    "    category = info.get('category', 'unknown')\n",
-    "    synthetic = ' (synthetic)' if info.get('synthetic') else ''\n",
-    "    print(f'   📦 {dataset_id}: {samples:,} samples [{category}]{synthetic}')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "6b0defc0",
-   "metadata": {},
-   "source": [
-    "## 🔍 Section 2: Data Loading and Exploration"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "85f355a6",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Load datasets by category for multi-domain training\n",
-    "\n",
-    "async def load_category_datasets(category: str, max_samples: int = 50000):\n",
-    "    \"\"\"Load and combine datasets from a specific category\"\"\"\n",
-    "    dfs = []\n",
-    "    for dataset_id, info in dataset_manager.downloaded_datasets.items():\n",
-    "        if info.get('category') == category:\n",
-    "            df = await dataset_manager.load_dataset(dataset_id)\n",
-    "            if df is not None:\n",
-    "                if len(df) > max_samples:\n",
-    "                    df = df.sample(n=max_samples, random_state=42)\n",
-    "                df['source_dataset'] = dataset_id\n",
-    "                dfs.append(df)\n",
-    "    \n",
-    "    if dfs:\n",
-    "        return pd.concat(dfs, ignore_index=True)\n",
-    "    return pd.DataFrame()\n",
-    "\n",
-    "# Load datasets for each domain\n",
-    "async def load_all_domain_data():\n",
-    "    domains = {}\n",
-    "    categories = ['phishing', 'malware', 'intrusion', 'web_attack', 'dns', 'spam']\n",
-    "    \n",
-    "    for cat in categories:\n",
-    "        df = await load_category_datasets(cat)\n",
-    "        if len(df) > 0:\n",
-    "            domains[cat] = df\n",
-    "            print(f'   ✅ {cat}: {len(df):,} samples')\n",
-    "    \n",
-    "    return domains\n",
-    "\n",
-    "print('📂 Loading domain-specific datasets...\\n')\n",
-    "\n",
-    "try:\n",
-    "    loop = asyncio.get_event_loop()\n",
-    "    if loop.is_running():\n",
-    "        domain_datasets = loop.run_until_complete(load_all_domain_data())\n",
-    "    else:\n",
-    "        domain_datasets = asyncio.run(load_all_domain_data())\n",
-    "except:\n",
-    "    domain_datasets = asyncio.run(load_all_domain_data())\n",
-    "\n",
-    "print(f'\\n📊 Loaded {len(domain_datasets)} security domains')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "acefa098",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Visualize dataset distributions\n",
-    "fig, axes = plt.subplots(2, 3, figsize=(15, 10))\n",
-    "axes = axes.ravel()\n",
-    "\n",
-    "for idx, (domain, df) in enumerate(domain_datasets.items()):\n",
-    "    if idx >= 6:\n",
-    "        break\n",
-    "    \n",
-    "    # Find target column\n",
-    "    target_cols = [c for c in df.columns if 'malicious' in c.lower() or 'attack' in c.lower() \n",
-    "                   or 'is_' in c.lower() or 'label' in c.lower() or 'result' in c.lower()]\n",
-    "    \n",
-    "    if target_cols:\n",
-    "        target = target_cols[0]\n",
-    "        df[target].value_counts().plot(kind='bar', ax=axes[idx], color=['#4ecdc4', '#ff6b6b'])\n",
-    "        axes[idx].set_title(f'{domain.upper()} - Target Distribution', color='white')\n",
-    "        axes[idx].set_xlabel('Class', color='white')\n",
-    "        axes[idx].set_ylabel('Count', color='white')\n",
-    "        axes[idx].tick_params(colors='white')\n",
-    "\n",
-    "plt.tight_layout()\n",
-    "plt.suptitle('🎯 Security Domain Dataset Distributions', y=1.02, fontsize=16, color='white')\n",
-    "plt.show()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "e80c5117",
-   "metadata": {},
-   "source": [
-    "## 🛠️ Section 3: Advanced Feature Engineering"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c6f87d02",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class AgenticSecurityFeatureEngineer:\n",
-    "    \"\"\"\n",
-    "    Advanced feature engineering for Agentic AI security models.\n",
-    "    Creates domain-specific features optimized for real-time detection.\n",
-    "    \"\"\"\n",
-    "    \n",
-    "    def __init__(self):\n",
-    "        self.scalers = {}\n",
-    "        self.encoders = {}\n",
-    "        self.feature_stats = {}\n",
-    "    \n",
-    "    def engineer_phishing_features(self, df: pd.DataFrame) -> pd.DataFrame:\n",
-    "        \"\"\"Create advanced phishing detection features\"\"\"\n",
-    "        df = df.copy()\n",
-    "        \n",
-    "        # URL entropy (if URL text is available)\n",
-    "        if 'url' in df.columns:\n",
-    "            df['url_entropy'] = df['url'].apply(self._calculate_entropy)\n",
-    "            df['url_digit_ratio'] = df['url'].apply(lambda x: sum(c.isdigit() for c in str(x)) / max(len(str(x)), 1))\n",
-    "            df['url_special_ratio'] = df['url'].apply(lambda x: sum(not c.isalnum() for c in str(x)) / max(len(str(x)), 1))\n",
-    "        \n",
-    "        # Composite risk scores\n",
-    "        numeric_cols = df.select_dtypes(include=[np.number]).columns\n",
-    "        if len(numeric_cols) > 0:\n",
-    "            df['risk_score'] = df[numeric_cols].mean(axis=1)\n",
-    "            df['risk_variance'] = df[numeric_cols].var(axis=1)\n",
-    "        \n",
-    "        return df\n",
-    "    \n",
-    "    def engineer_malware_features(self, df: pd.DataFrame) -> pd.DataFrame:\n",
-    "        \"\"\"Create advanced malware detection features\"\"\"\n",
-    "        df = df.copy()\n",
-    "        \n",
-    "        # Entropy-based features\n",
-    "        if 'entropy' in df.columns:\n",
-    "            df['high_entropy'] = (df['entropy'] > 7.0).astype(int)\n",
-    "            df['entropy_squared'] = df['entropy'] ** 2\n",
-    "        \n",
-    "        # Size-based features\n",
-    "        if 'file_size' in df.columns:\n",
-    "            df['log_file_size'] = np.log1p(df['file_size'])\n",
-    "            df['size_category'] = pd.cut(df['file_size'], bins=[0, 10000, 100000, 1000000, np.inf], \n",
-    "                                         labels=[0, 1, 2, 3]).astype(int)\n",
-    "        \n",
-    "        # API/Import analysis\n",
-    "        if 'suspicious_api_calls' in df.columns and 'imports_count' in df.columns:\n",
-    "            df['api_to_import_ratio'] = df['suspicious_api_calls'] / (df['imports_count'] + 1)\n",
-    "        \n",
-    "        return df\n",
-    "    \n",
-    "    def engineer_intrusion_features(self, df: pd.DataFrame) -> pd.DataFrame:\n",
-    "        \"\"\"Create advanced network intrusion features\"\"\"\n",
-    "        df = df.copy()\n",
-    "        \n",
-    "        # Traffic volume features\n",
-    "        if 'src_bytes' in df.columns and 'dst_bytes' in df.columns:\n",
-    "            df['total_bytes'] = df['src_bytes'] + df['dst_bytes']\n",
-    "            df['bytes_ratio'] = df['src_bytes'] / (df['dst_bytes'] + 1)\n",
-    "            df['log_total_bytes'] = np.log1p(df['total_bytes'])\n",
-    "        \n",
-    "        # Connection features\n",
-    "        if 'duration' in df.columns:\n",
-    "            df['log_duration'] = np.log1p(df['duration'])\n",
-    "            df['short_connection'] = (df['duration'] < 1).astype(int)\n",
-    "        \n",
-    "        # Error rate features\n",
-    "        if 'serror_rate' in df.columns:\n",
-    "            df['high_error_rate'] = (df['serror_rate'] > 0.5).astype(int)\n",
-    "        \n",
-    "        return df\n",
-    "    \n",
-    "    def engineer_web_attack_features(self, df: pd.DataFrame) -> pd.DataFrame:\n",
-    "        \"\"\"Create advanced web attack detection features\"\"\"\n",
-    "        df = df.copy()\n",
-    "        \n",
-    "        # Payload analysis\n",
-    "        if 'payload' in df.columns:\n",
-    "            df['payload_length'] = df['payload'].apply(lambda x: len(str(x)))\n",
-    "            df['payload_entropy'] = df['payload'].apply(self._calculate_entropy)\n",
-    "            df['has_script_tag'] = df['payload'].apply(lambda x: 1 if '<script' in str(x).lower() else 0)\n",
-    "            df['has_sql_keyword'] = df['payload'].apply(\n",
-    "                lambda x: 1 if any(kw in str(x).lower() for kw in ['select', 'union', 'drop', 'insert']) else 0\n",
-    "            )\n",
-    "        \n",
-    "        # URL features\n",
-    "        if 'url_length' in df.columns:\n",
-    "            df['long_url'] = (df['url_length'] > 100).astype(int)\n",
-    "        \n",
-    "        return df\n",
-    "    \n",
-    "    def engineer_dns_features(self, df: pd.DataFrame) -> pd.DataFrame:\n",
-    "        \"\"\"Create advanced DNS/DGA detection features\"\"\"\n",
-    "        df = df.copy()\n",
-    "        \n",
-    "        if 'domain' in df.columns:\n",
-    "            df['domain_entropy'] = df['domain'].apply(self._calculate_entropy)\n",
-    "            df['consonant_ratio'] = df['domain'].apply(self._consonant_ratio)\n",
-    "            df['digit_ratio'] = df['domain'].apply(lambda x: sum(c.isdigit() for c in str(x)) / max(len(str(x)), 1))\n",
-    "        \n",
-    "        if 'entropy' in df.columns:\n",
-    "            df['entropy_normalized'] = (df['entropy'] - df['entropy'].min()) / (df['entropy'].max() - df['entropy'].min() + 1e-8)\n",
-    "        \n",
-    "        return df\n",
-    "    \n",
-    "    def _calculate_entropy(self, text: str) -> float:\n",
-    "        \"\"\"Calculate Shannon entropy of text\"\"\"\n",
-    "        if not text or pd.isna(text):\n",
-    "            return 0.0\n",
-    "        text = str(text)\n",
-    "        prob = [float(text.count(c)) / len(text) for c in set(text)]\n",
-    "        return -sum(p * np.log2(p) for p in prob if p > 0)\n",
-    "    \n",
-    "    def _consonant_ratio(self, text: str) -> float:\n",
-    "        \"\"\"Calculate consonant to vowel ratio\"\"\"\n",
-    "        if not text or pd.isna(text):\n",
-    "            return 0.0\n",
-    "        text = str(text).lower()\n",
-    "        vowels = set('aeiou')\n",
-    "        consonants = sum(1 for c in text if c.isalpha() and c not in vowels)\n",
-    "        total_letters = sum(1 for c in text if c.isalpha())\n",
-    "        return consonants / max(total_letters, 1)\n",
-    "    \n",
-    "    def process_dataset(self, df: pd.DataFrame, domain: str) -> pd.DataFrame:\n",
-    "        \"\"\"Apply domain-specific feature engineering\"\"\"\n",
-    "        engineers = {\n",
-    "            'phishing': self.engineer_phishing_features,\n",
-    "            'malware': self.engineer_malware_features,\n",
-    "            'intrusion': self.engineer_intrusion_features,\n",
-    "            'web_attack': self.engineer_web_attack_features,\n",
-    "            'dns': self.engineer_dns_features,\n",
-    "        }\n",
-    "        \n",
-    "        engineer_func = engineers.get(domain)\n",
-    "        if engineer_func:\n",
-    "            return engineer_func(df)\n",
-    "        return df\n",
-    "\n",
-    "# Initialize feature engineer\n",
-    "feature_engineer = AgenticSecurityFeatureEngineer()\n",
-    "print('✅ Feature engineer initialized')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "039a7ae5",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Apply feature engineering to all domains\n",
-    "print('🔧 Applying advanced feature engineering...\\n')\n",
-    "\n",
-    "engineered_datasets = {}\n",
-    "for domain, df in domain_datasets.items():\n",
-    "    original_features = len(df.columns)\n",
-    "    engineered_df = feature_engineer.process_dataset(df, domain)\n",
-    "    new_features = len(engineered_df.columns)\n",
-    "    engineered_datasets[domain] = engineered_df\n",
-    "    print(f'   {domain}: {original_features} → {new_features} features (+{new_features - original_features})')\n",
-    "\n",
-    "print('\\n✅ Feature engineering complete!')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "aa853980",
-   "metadata": {},
-   "source": [
-    "## 🤖 Section 4: Model Architecture Definitions"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8aa31308",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class AgenticSecurityModels:\n",
-    "    \"\"\"\n",
-    "    Advanced ML/DL model architectures for agentic AI security.\n",
-    "    Optimized for real-time inference and high accuracy.\n",
-    "    \"\"\"\n",
-    "    \n",
-    "    @staticmethod\n",
-    "    def create_deep_neural_network(input_dim: int, \n",
-    "                                   name: str = 'security_dnn',\n",
-    "                                   hidden_layers: list = [256, 128, 64, 32],\n",
-    "                                   dropout_rate: float = 0.3) -> Model:\n",
-    "        \"\"\"Create a deep neural network for security classification\"\"\"\n",
-    "        \n",
-    "        inputs = Input(shape=(input_dim,), name='input')\n",
-    "        x = inputs\n",
-    "        \n",
-    "        for i, units in enumerate(hidden_layers):\n",
-    "            x = Dense(units, activation='relu', \n",
-    "                     kernel_regularizer=l2(0.001),\n",
-    "                     name=f'dense_{i}')(x)\n",
-    "            x = BatchNormalization(name=f'bn_{i}')(x)\n",
-    "            x = Dropout(dropout_rate * (1 - i * 0.1), name=f'dropout_{i}')(x)\n",
-    "        \n",
-    "        outputs = Dense(1, activation='sigmoid', name='output')(x)\n",
-    "        \n",
-    "        model = Model(inputs, outputs, name=name)\n",
-    "        model.compile(\n",
-    "            optimizer=Adam(learning_rate=0.001),\n",
-    "            loss='binary_crossentropy',\n",
-    "            metrics=['accuracy', 'precision', 'recall', 'AUC']\n",
-    "        )\n",
-    "        \n",
-    "        return model\n",
-    "    \n",
-    "    @staticmethod\n",
-    "    def create_wide_and_deep(input_dim: int, name: str = 'wide_deep') -> Model:\n",
-    "        \"\"\"Create Wide & Deep architecture for combining memorization and generalization\"\"\"\n",
-    "        \n",
-    "        inputs = Input(shape=(input_dim,))\n",
-    "        \n",
-    "        # Wide component (linear)\n",
-    "        wide = Dense(1, activation=None, name='wide')(inputs)\n",
-    "        \n",
-    "        # Deep component\n",
-    "        deep = Dense(128, activation='relu')(inputs)\n",
-    "        deep = BatchNormalization()(deep)\n",
-    "        deep = Dropout(0.3)(deep)\n",
-    "        deep = Dense(64, activation='relu')(deep)\n",
-    "        deep = BatchNormalization()(deep)\n",
-    "        deep = Dropout(0.2)(deep)\n",
-    "        deep = Dense(32, activation='relu')(deep)\n",
-    "        deep = Dense(1, activation=None, name='deep')(deep)\n",
-    "        \n",
-    "        # Combine wide and deep\n",
-    "        combined = tf.keras.layers.Add()([wide, deep])\n",
-    "        outputs = tf.keras.layers.Activation('sigmoid')(combined)\n",
-    "        \n",
-    "        model = Model(inputs, outputs, name=name)\n",
-    "        model.compile(\n",
-    "            optimizer=Adam(learning_rate=0.001),\n",
-    "            loss='binary_crossentropy',\n",
-    "            metrics=['accuracy', 'precision', 'recall', 'AUC']\n",
-    "        )\n",
-    "        \n",
-    "        return model\n",
-    "    \n",
-    "    @staticmethod\n",
-    "    def create_residual_network(input_dim: int, name: str = 'resnet') -> Model:\n",
-    "        \"\"\"Create Residual Network for security classification\"\"\"\n",
-    "        \n",
-    "        def residual_block(x, units):\n",
-    "            shortcut = x\n",
-    "            \n",
-    "            x = Dense(units, activation='relu')(x)\n",
-    "            x = BatchNormalization()(x)\n",
-    "            x = Dense(units, activation=None)(x)\n",
-    "            x = BatchNormalization()(x)\n",
-    "            \n",
-    "            # Match dimensions if needed\n",
-    "            if shortcut.shape[-1] != units:\n",
-    "                shortcut = Dense(units, activation=None)(shortcut)\n",
-    "            \n",
-    "            x = tf.keras.layers.Add()([x, shortcut])\n",
-    "            x = tf.keras.layers.Activation('relu')(x)\n",
-    "            return x\n",
-    "        \n",
-    "        inputs = Input(shape=(input_dim,))\n",
-    "        \n",
-    "        # Initial projection\n",
-    "        x = Dense(128, activation='relu')(inputs)\n",
-    "        x = BatchNormalization()(x)\n",
-    "        \n",
-    "        # Residual blocks\n",
-    "        x = residual_block(x, 128)\n",
-    "        x = Dropout(0.3)(x)\n",
-    "        x = residual_block(x, 64)\n",
-    "        x = Dropout(0.2)(x)\n",
-    "        x = residual_block(x, 32)\n",
-    "        \n",
-    "        # Output\n",
-    "        outputs = Dense(1, activation='sigmoid')(x)\n",
-    "        \n",
-    "        model = Model(inputs, outputs, name=name)\n",
-    "        model.compile(\n",
-    "            optimizer=Adam(learning_rate=0.001),\n",
-    "            loss='binary_crossentropy',\n",
-    "            metrics=['accuracy', 'precision', 'recall', 'AUC']\n",
-    "        )\n",
-    "        \n",
-    "        return model\n",
-    "    \n",
-    "    @staticmethod\n",
-    "    def create_xgboost_classifier(n_estimators: int = 200) -> xgb.XGBClassifier:\n",
-    "        \"\"\"Create optimized XGBoost classifier\"\"\"\n",
-    "        return xgb.XGBClassifier(\n",
-    "            n_estimators=n_estimators,\n",
-    "            max_depth=10,\n",
-    "            learning_rate=0.1,\n",
-    "            subsample=0.8,\n",
-    "            colsample_bytree=0.8,\n",
-    "            reg_alpha=0.1,\n",
-    "            reg_lambda=1.0,\n",
-    "            random_state=42,\n",
-    "            n_jobs=-1,\n",
-    "            use_label_encoder=False,\n",
-    "            eval_metric='logloss'\n",
-    "        )\n",
-    "    \n",
-    "    @staticmethod\n",
-    "    def create_random_forest(n_estimators: int = 200) -> RandomForestClassifier:\n",
-    "        \"\"\"Create optimized Random Forest classifier\"\"\"\n",
-    "        return RandomForestClassifier(\n",
-    "            n_estimators=n_estimators,\n",
-    "            max_depth=20,\n",
-    "            min_samples_split=5,\n",
-    "            min_samples_leaf=2,\n",
-    "            max_features='sqrt',\n",
-    "            class_weight='balanced',\n",
-    "            random_state=42,\n",
-    "            n_jobs=-1\n",
-    "        )\n",
-    "\n",
-    "print('✅ Model architectures defined')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "f0eeb16b",
-   "metadata": {},
-   "source": [
-    "## 🎯 Section 5: Multi-Domain Model Training"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "ff04c2d3",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class AgenticSecurityTrainer:\n",
-    "    \"\"\"\n",
-    "    Comprehensive training pipeline for multi-domain security models.\n",
-    "    \"\"\"\n",
-    "    \n",
-    "    def __init__(self, models_dir: str = '../models/agentic_security'):\n",
-    "        self.models_dir = Path(models_dir)\n",
-    "        self.models_dir.mkdir(parents=True, exist_ok=True)\n",
-    "        self.trained_models = {}\n",
-    "        self.scalers = {}\n",
-    "        self.feature_names = {}\n",
-    "        self.metrics = {}\n",
-    "    \n",
-    "    def prepare_data(self, df: pd.DataFrame, domain: str) -> tuple:\n",
-    "        \"\"\"Prepare data for training\"\"\"\n",
-    "        \n",
-    "        # Find target column\n",
-    "        target_candidates = ['is_malicious', 'is_attack', 'is_malware', 'is_spam', \n",
-    "                            'is_dga', 'is_miner', 'is_suspicious', 'label', 'result']\n",
-    "        \n",
-    "        target_col = None\n",
-    "        for col in target_candidates:\n",
-    "            if col in df.columns:\n",
-    "                target_col = col\n",
-    "                break\n",
-    "        \n",
-    "        if target_col is None:\n",
-    "            # Try to find any binary column\n",
-    "            for col in df.columns:\n",
-    "                if df[col].nunique() == 2 and df[col].dtype in [np.int64, np.int32, np.float64]:\n",
-    "                    target_col = col\n",
-    "                    break\n",
-    "        \n",
-    "        if target_col is None:\n",
-    "            raise ValueError(f'No suitable target column found for {domain}')\n",
-    "        \n",
-    "        # Select numeric features only\n",
-    "        exclude_cols = [target_col, 'source_dataset', '_dataset_id', '_category',\n",
-    "                       'url', 'payload', 'domain', 'ip_address', 'attack_type']\n",
-    "        \n",
-    "        feature_cols = [col for col in df.select_dtypes(include=[np.number]).columns \n",
-    "                       if col not in exclude_cols]\n",
-    "        \n",
-    "        X = df[feature_cols].fillna(0)\n",
-    "        y = df[target_col].astype(int)\n",
-    "        \n",
-    "        # Remove infinite values\n",
-    "        X = X.replace([np.inf, -np.inf], 0)\n",
-    "        \n",
-    "        self.feature_names[domain] = feature_cols\n",
-    "        \n",
-    "        return X, y, feature_cols\n",
-    "    \n",
-    "    def train_domain_models(self, df: pd.DataFrame, domain: str) -> dict:\n",
-    "        \"\"\"Train all models for a specific security domain\"\"\"\n",
-    "        \n",
-    "        print(f'\\n🎯 Training models for: {domain.upper()}')\n",
-    "        print('=' * 50)\n",
-    "        \n",
-    "        # Prepare data\n",
-    "        X, y, feature_cols = self.prepare_data(df, domain)\n",
-    "        print(f'   📊 Data: {X.shape[0]:,} samples, {X.shape[1]} features')\n",
-    "        print(f'   ⚖️ Class balance: {y.value_counts().to_dict()}')\n",
-    "        \n",
-    "        # Split data\n",
-    "        X_train, X_test, y_train, y_test = train_test_split(\n",
-    "            X, y, test_size=0.2, random_state=42, stratify=y\n",
-    "        )\n",
-    "        \n",
-    "        # Scale features\n",
-    "        scaler = StandardScaler()\n",
-    "        X_train_scaled = scaler.fit_transform(X_train)\n",
-    "        X_test_scaled = scaler.transform(X_test)\n",
-    "        self.scalers[domain] = scaler\n",
-    "        \n",
-    "        # Handle class imbalance\n",
-    "        try:\n",
-    "            smote = SMOTE(random_state=42)\n",
-    "            X_train_balanced, y_train_balanced = smote.fit_resample(X_train_scaled, y_train)\n",
-    "            print(f'   ⚖️ After SMOTE: {len(X_train_balanced):,} samples')\n",
-    "        except:\n",
-    "            X_train_balanced, y_train_balanced = X_train_scaled, y_train\n",
-    "            print('   ⚠️ SMOTE skipped')\n",
-    "        \n",
-    "        results = {}\n",
-    "        \n",
-    "        # 1. Train Random Forest\n",
-    "        print('\\n   🌲 Training Random Forest...')\n",
-    "        rf = AgenticSecurityModels.create_random_forest()\n",
-    "        rf.fit(X_train_balanced, y_train_balanced)\n",
-    "        rf_pred = rf.predict(X_test_scaled)\n",
-    "        rf_proba = rf.predict_proba(X_test_scaled)[:, 1]\n",
-    "        results['random_forest'] = {\n",
-    "            'model': rf,\n",
-    "            'predictions': rf_pred,\n",
-    "            'probabilities': rf_proba,\n",
-    "            'accuracy': accuracy_score(y_test, rf_pred),\n",
-    "            'f1': f1_score(y_test, rf_pred),\n",
-    "            'auc': roc_auc_score(y_test, rf_proba)\n",
-    "        }\n",
-    "        print(f'      Accuracy: {results[\"random_forest\"][\"accuracy\"]:.4f}, AUC: {results[\"random_forest\"][\"auc\"]:.4f}')\n",
-    "        \n",
-    "        # 2. Train XGBoost\n",
-    "        print('   🚀 Training XGBoost...')\n",
-    "        xgb_model = AgenticSecurityModels.create_xgboost_classifier()\n",
-    "        xgb_model.fit(X_train_balanced, y_train_balanced)\n",
-    "        xgb_pred = xgb_model.predict(X_test_scaled)\n",
-    "        xgb_proba = xgb_model.predict_proba(X_test_scaled)[:, 1]\n",
-    "        results['xgboost'] = {\n",
-    "            'model': xgb_model,\n",
-    "            'predictions': xgb_pred,\n",
-    "            'probabilities': xgb_proba,\n",
-    "            'accuracy': accuracy_score(y_test, xgb_pred),\n",
-    "            'f1': f1_score(y_test, xgb_pred),\n",
-    "            'auc': roc_auc_score(y_test, xgb_proba)\n",
-    "        }\n",
-    "        print(f'      Accuracy: {results[\"xgboost\"][\"accuracy\"]:.4f}, AUC: {results[\"xgboost\"][\"auc\"]:.4f}')\n",
-    "        \n",
-    "        # 3. Train Deep Neural Network\n",
-    "        print('   🧠 Training Deep Neural Network...')\n",
-    "        dnn = AgenticSecurityModels.create_deep_neural_network(X_train_scaled.shape[1], name=f'{domain}_dnn')\n",
-    "        \n",
-    "        callbacks = [\n",
-    "            EarlyStopping(monitor='val_loss', patience=10, restore_best_weights=True),\n",
-    "            ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=5, min_lr=1e-6)\n",
-    "        ]\n",
-    "        \n",
-    "        history = dnn.fit(\n",
-    "            X_train_balanced, y_train_balanced,\n",
-    "            epochs=50,\n",
-    "            batch_size=64,\n",
-    "            validation_split=0.2,\n",
-    "            callbacks=callbacks,\n",
-    "            verbose=0\n",
-    "        )\n",
-    "        \n",
-    "        dnn_proba = dnn.predict(X_test_scaled, verbose=0).flatten()\n",
-    "        dnn_pred = (dnn_proba > 0.5).astype(int)\n",
-    "        results['deep_neural_network'] = {\n",
-    "            'model': dnn,\n",
-    "            'predictions': dnn_pred,\n",
-    "            'probabilities': dnn_proba,\n",
-    "            'accuracy': accuracy_score(y_test, dnn_pred),\n",
-    "            'f1': f1_score(y_test, dnn_pred),\n",
-    "            'auc': roc_auc_score(y_test, dnn_proba)\n",
-    "        }\n",
-    "        print(f'      Accuracy: {results[\"deep_neural_network\"][\"accuracy\"]:.4f}, AUC: {results[\"deep_neural_network\"][\"auc\"]:.4f}')\n",
-    "        \n",
-    "        # 4. Create Ensemble\n",
-    "        print('   🎭 Creating Ensemble...')\n",
-    "        weights = np.array([r['auc'] for r in results.values()])\n",
-    "        weights = weights / weights.sum()\n",
-    "        \n",
-    "        ensemble_proba = (\n",
-    "            weights[0] * rf_proba +\n",
-    "            weights[1] * xgb_proba +\n",
-    "            weights[2] * dnn_proba\n",
-    "        )\n",
-    "        ensemble_pred = (ensemble_proba > 0.5).astype(int)\n",
-    "        \n",
-    "        results['ensemble'] = {\n",
-    "            'weights': weights.tolist(),\n",
-    "            'predictions': ensemble_pred,\n",
-    "            'probabilities': ensemble_proba,\n",
-    "            'accuracy': accuracy_score(y_test, ensemble_pred),\n",
-    "            'f1': f1_score(y_test, ensemble_pred),\n",
-    "            'auc': roc_auc_score(y_test, ensemble_proba)\n",
-    "        }\n",
-    "        print(f'      Accuracy: {results[\"ensemble\"][\"accuracy\"]:.4f}, AUC: {results[\"ensemble\"][\"auc\"]:.4f}')\n",
-    "        \n",
-    "        # Store metrics\n",
-    "        self.metrics[domain] = {\n",
-    "            model_name: {\n",
-    "                'accuracy': r['accuracy'],\n",
-    "                'f1': r['f1'],\n",
-    "                'auc': r['auc']\n",
-    "            }\n",
-    "            for model_name, r in results.items()\n",
-    "        }\n",
-    "        \n",
-    "        self.trained_models[domain] = results\n",
-    "        \n",
-    "        return results\n",
-    "    \n",
-    "    def save_models(self):\n",
-    "        \"\"\"Save all trained models\"\"\"\n",
-    "        print('\\n💾 Saving trained models...')\n",
-    "        \n",
-    "        for domain, results in self.trained_models.items():\n",
-    "            domain_dir = self.models_dir / domain\n",
-    "            domain_dir.mkdir(exist_ok=True)\n",
-    "            \n",
-    "            # Save sklearn models\n",
-    "            if 'random_forest' in results:\n",
-    "                joblib.dump(results['random_forest']['model'], domain_dir / 'random_forest.pkl')\n",
-    "            if 'xgboost' in results:\n",
-    "                joblib.dump(results['xgboost']['model'], domain_dir / 'xgboost.pkl')\n",
-    "            \n",
-    "            # Save Keras model\n",
-    "            if 'deep_neural_network' in results:\n",
-    "                results['deep_neural_network']['model'].save(domain_dir / 'deep_neural_network.keras')\n",
-    "            \n",
-    "            # Save scaler\n",
-    "            if domain in self.scalers:\n",
-    "                joblib.dump(self.scalers[domain], domain_dir / 'scaler.pkl')\n",
-    "            \n",
-    "            # Save feature names\n",
-    "            if domain in self.feature_names:\n",
-    "                joblib.dump(self.feature_names[domain], domain_dir / 'feature_names.pkl')\n",
-    "            \n",
-    "            # Save ensemble config\n",
-    "            if 'ensemble' in results:\n",
-    "                config = {\n",
-    "                    'weights': results['ensemble']['weights'],\n",
-    "                    'models': ['random_forest', 'xgboost', 'deep_neural_network'],\n",
-    "                    'threshold': 0.5\n",
-    "                }\n",
-    "                joblib.dump(config, domain_dir / 'ensemble_config.pkl')\n",
-    "            \n",
-    "            print(f'   ✅ Saved {domain} models to {domain_dir}')\n",
-    "        \n",
-    "        # Save overall metrics\n",
-    "        with open(self.models_dir / 'training_metrics.json', 'w') as f:\n",
-    "            json.dump(self.metrics, f, indent=2)\n",
-    "        \n",
-    "        print(f'\\n🎉 All models saved to {self.models_dir}')\n",
-    "\n",
-    "# Initialize trainer\n",
-    "trainer = AgenticSecurityTrainer()\n",
-    "print('✅ Trainer initialized')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "d21ba338",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Train models for all security domains\n",
-    "print('🚀 Starting Multi-Domain Security Model Training')\n",
-    "print('=' * 60)\n",
-    "\n",
-    "for domain, df in engineered_datasets.items():\n",
-    "    if len(df) < 100:\n",
-    "        print(f'\\n⚠️ Skipping {domain} - insufficient data ({len(df)} samples)')\n",
-    "        continue\n",
-    "    \n",
-    "    try:\n",
-    "        trainer.train_domain_models(df, domain)\n",
-    "    except Exception as e:\n",
-    "        print(f'\\n❌ Error training {domain}: {e}')\n",
-    "        continue\n",
-    "\n",
-    "print('\\n' + '=' * 60)\n",
-    "print('🎉 Multi-Domain Training Complete!')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "50fe57e8",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Visualize training results\n",
-    "if trainer.metrics:\n",
-    "    # Create comparison visualization\n",
-    "    fig, axes = plt.subplots(1, 3, figsize=(18, 6))\n",
-    "    \n",
-    "    metrics_to_plot = ['accuracy', 'f1', 'auc']\n",
-    "    colors = ['#4ecdc4', '#ff6b6b', '#ffe66d', '#95e1d3']\n",
-    "    \n",
-    "    for idx, metric in enumerate(metrics_to_plot):\n",
-    "        data = []\n",
-    "        labels = []\n",
-    "        \n",
-    "        for domain, models in trainer.metrics.items():\n",
-    "            for model_name, model_metrics in models.items():\n",
-    "                data.append(model_metrics[metric])\n",
-    "                labels.append(f'{domain}\\n{model_name}')\n",
-    "        \n",
-    "        x = range(len(data))\n",
-    "        axes[idx].bar(x, data, color=colors * 10)\n",
-    "        axes[idx].set_xticks(x)\n",
-    "        axes[idx].set_xticklabels(labels, rotation=45, ha='right', fontsize=8)\n",
-    "        axes[idx].set_ylabel(metric.upper(), color='white')\n",
-    "        axes[idx].set_title(f'{metric.upper()} Across Models', color='white', fontsize=14)\n",
-    "        axes[idx].set_ylim(0, 1)\n",
-    "        axes[idx].axhline(y=0.9, color='red', linestyle='--', alpha=0.5, label='90% threshold')\n",
-    "        axes[idx].grid(True, alpha=0.3)\n",
-    "    \n",
-    "    plt.tight_layout()\n",
-    "    plt.suptitle('🎯 Multi-Domain Security Model Performance', y=1.02, fontsize=16, color='white')\n",
-    "    plt.show()\n",
-    "\n",
-    "# Print summary table\n",
-    "print('\\n📊 Training Results Summary')\n",
-    "print('=' * 80)\n",
-    "print(f'{\"Domain\":<15} {\"Model\":<25} {\"Accuracy\":<12} {\"F1\":<12} {\"AUC\":<12}')\n",
-    "print('-' * 80)\n",
-    "\n",
-    "for domain, models in trainer.metrics.items():\n",
-    "    for model_name, metrics in models.items():\n",
-    "        print(f'{domain:<15} {model_name:<25} {metrics[\"accuracy\"]:<12.4f} {metrics[\"f1\"]:<12.4f} {metrics[\"auc\"]:<12.4f}')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "3a12da59",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Save all trained models\n",
-    "trainer.save_models()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "fdfb081b",
-   "metadata": {},
-   "source": [
-    "## 🚀 Section 6: Real-Time Inference API"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "c2ef7b51",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class AgenticSecurityInference:\n",
-    "    \"\"\"\n",
-    "    Real-time inference engine for the Agentic AI security system.\n",
-    "    Provides unified API for all security domains.\n",
-    "    \"\"\"\n",
-    "    \n",
-    "    def __init__(self, models_dir: str = '../models/agentic_security'):\n",
-    "        self.models_dir = Path(models_dir)\n",
-    "        self.models = {}\n",
-    "        self.scalers = {}\n",
-    "        self.feature_names = {}\n",
-    "        self.ensemble_configs = {}\n",
-    "        self._load_models()\n",
-    "    \n",
-    "    def _load_models(self):\n",
-    "        \"\"\"Load all trained models\"\"\"\n",
-    "        print('📦 Loading trained models...')\n",
-    "        \n",
-    "        for domain_dir in self.models_dir.iterdir():\n",
-    "            if domain_dir.is_dir():\n",
-    "                domain = domain_dir.name\n",
-    "                self.models[domain] = {}\n",
-    "                \n",
-    "                # Load sklearn models\n",
-    "                rf_path = domain_dir / 'random_forest.pkl'\n",
-    "                if rf_path.exists():\n",
-    "                    self.models[domain]['random_forest'] = joblib.load(rf_path)\n",
-    "                \n",
-    "                xgb_path = domain_dir / 'xgboost.pkl'\n",
-    "                if xgb_path.exists():\n",
-    "                    self.models[domain]['xgboost'] = joblib.load(xgb_path)\n",
-    "                \n",
-    "                # Load Keras model\n",
-    "                dnn_path = domain_dir / 'deep_neural_network.keras'\n",
-    "                if dnn_path.exists():\n",
-    "                    self.models[domain]['dnn'] = tf.keras.models.load_model(dnn_path)\n",
-    "                \n",
-    "                # Load scaler\n",
-    "                scaler_path = domain_dir / 'scaler.pkl'\n",
-    "                if scaler_path.exists():\n",
-    "                    self.scalers[domain] = joblib.load(scaler_path)\n",
-    "                \n",
-    "                # Load feature names\n",
-    "                features_path = domain_dir / 'feature_names.pkl'\n",
-    "                if features_path.exists():\n",
-    "                    self.feature_names[domain] = joblib.load(features_path)\n",
-    "                \n",
-    "                # Load ensemble config\n",
-    "                config_path = domain_dir / 'ensemble_config.pkl'\n",
-    "                if config_path.exists():\n",
-    "                    self.ensemble_configs[domain] = joblib.load(config_path)\n",
-    "                \n",
-    "                print(f'   ✅ Loaded {domain}: {list(self.models[domain].keys())}')\n",
-    "        \n",
-    "        print(f'\\n🎉 Loaded models for {len(self.models)} security domains')\n",
-    "    \n",
-    "    def predict(self, features: dict, domain: str, use_ensemble: bool = True) -> dict:\n",
-    "        \"\"\"\n",
-    "        Make a real-time security prediction.\n",
-    "        \n",
-    "        Args:\n",
-    "            features: Dictionary of feature values\n",
-    "            domain: Security domain (phishing, malware, intrusion, etc.)\n",
-    "            use_ensemble: Whether to use ensemble prediction\n",
-    "        \n",
-    "        Returns:\n",
-    "            Prediction result with confidence and risk assessment\n",
-    "        \"\"\"\n",
-    "        if domain not in self.models:\n",
-    "            return {'error': f'Unknown domain: {domain}', 'available_domains': list(self.models.keys())}\n",
-    "        \n",
-    "        try:\n",
-    "            # Prepare features\n",
-    "            feature_names = self.feature_names.get(domain, list(features.keys()))\n",
-    "            X = np.zeros((1, len(feature_names)))\n",
-    "            \n",
-    "            for i, fname in enumerate(feature_names):\n",
-    "                if fname in features:\n",
-    "                    X[0, i] = features[fname]\n",
-    "            \n",
-    "            # Scale features\n",
-    "            if domain in self.scalers:\n",
-    "                X_scaled = self.scalers[domain].transform(X)\n",
-    "            else:\n",
-    "                X_scaled = X\n",
-    "            \n",
-    "            # Get predictions from each model\n",
-    "            probabilities = {}\n",
-    "            \n",
-    "            if 'random_forest' in self.models[domain]:\n",
-    "                probabilities['random_forest'] = float(self.models[domain]['random_forest'].predict_proba(X_scaled)[0, 1])\n",
-    "            \n",
-    "            if 'xgboost' in self.models[domain]:\n",
-    "                probabilities['xgboost'] = float(self.models[domain]['xgboost'].predict_proba(X_scaled)[0, 1])\n",
-    "            \n",
-    "            if 'dnn' in self.models[domain]:\n",
-    "                probabilities['dnn'] = float(self.models[domain]['dnn'].predict(X_scaled, verbose=0)[0, 0])\n",
-    "            \n",
-    "            # Calculate ensemble probability\n",
-    "            if use_ensemble and domain in self.ensemble_configs:\n",
-    "                weights = self.ensemble_configs[domain]['weights']\n",
-    "                prob_values = list(probabilities.values())\n",
-    "                threat_probability = sum(w * p for w, p in zip(weights, prob_values))\n",
-    "            else:\n",
-    "                threat_probability = np.mean(list(probabilities.values()))\n",
-    "            \n",
-    "            # Determine prediction and risk level\n",
-    "            is_threat = threat_probability > 0.5\n",
-    "            confidence = threat_probability if is_threat else 1 - threat_probability\n",
-    "            \n",
-    "            if threat_probability > 0.9:\n",
-    "                risk_level = 'CRITICAL'\n",
-    "            elif threat_probability > 0.7:\n",
-    "                risk_level = 'HIGH'\n",
-    "            elif threat_probability > 0.5:\n",
-    "                risk_level = 'MEDIUM'\n",
-    "            elif threat_probability > 0.3:\n",
-    "                risk_level = 'LOW'\n",
-    "            else:\n",
-    "                risk_level = 'MINIMAL'\n",
-    "            \n",
-    "            return {\n",
-    "                'domain': domain,\n",
-    "                'prediction': 'THREAT' if is_threat else 'SAFE',\n",
-    "                'threat_probability': round(threat_probability, 4),\n",
-    "                'confidence': round(confidence, 4),\n",
-    "                'risk_level': risk_level,\n",
-    "                'model_scores': probabilities,\n",
-    "                'timestamp': datetime.now().isoformat()\n",
-    "            }\n",
-    "            \n",
-    "        except Exception as e:\n",
-    "            return {'error': str(e), 'domain': domain}\n",
-    "    \n",
-    "    def analyze_url(self, url_features: dict) -> dict:\n",
-    "        \"\"\"Specialized URL/phishing analysis\"\"\"\n",
-    "        return self.predict(url_features, 'phishing')\n",
-    "    \n",
-    "    def analyze_file(self, file_features: dict) -> dict:\n",
-    "        \"\"\"Specialized file/malware analysis\"\"\"\n",
-    "        return self.predict(file_features, 'malware')\n",
-    "    \n",
-    "    def analyze_network(self, network_features: dict) -> dict:\n",
-    "        \"\"\"Specialized network/intrusion analysis\"\"\"\n",
-    "        return self.predict(network_features, 'intrusion')\n",
-    "    \n",
-    "    def analyze_request(self, request_features: dict) -> dict:\n",
-    "        \"\"\"Specialized web request/attack analysis\"\"\"\n",
-    "        return self.predict(request_features, 'web_attack')\n",
-    "\n",
-    "# Initialize inference engine\n",
-    "inference = AgenticSecurityInference()\n",
-    "print('\\n✅ Inference engine ready!')"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6070af31",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Test the inference engine with sample data\n",
-    "print('🧪 Testing Inference Engine\\n')\n",
-    "\n",
-    "# Test phishing detection\n",
-    "phishing_sample = {\n",
-    "    'url_length': 250,\n",
-    "    'num_dots': 8,\n",
-    "    'has_ip': 1,\n",
-    "    'has_at_symbol': 1,\n",
-    "    'subdomain_level': 5,\n",
-    "    'domain_age_days': 15,\n",
-    "    'has_https': 0,\n",
-    "    'special_char_count': 12\n",
-    "}\n",
-    "\n",
-    "result = inference.analyze_url(phishing_sample)\n",
-    "print('🔗 Phishing Analysis Result:')\n",
-    "print(f'   Prediction: {result.get(\"prediction\", \"N/A\")}')\n",
-    "print(f'   Threat Probability: {result.get(\"threat_probability\", 0):.2%}')\n",
-    "print(f'   Risk Level: {result.get(\"risk_level\", \"N/A\")}')\n",
-    "print(f'   Confidence: {result.get(\"confidence\", 0):.2%}')\n",
-    "\n",
-    "# Test malware detection\n",
-    "malware_sample = {\n",
-    "    'file_size': 1048576,\n",
-    "    'entropy': 7.8,\n",
-    "    'pe_sections': 12,\n",
-    "    'imports_count': 250,\n",
-    "    'suspicious_api_calls': 15,\n",
-    "    'packed': 1\n",
-    "}\n",
-    "\n",
-    "result = inference.analyze_file(malware_sample)\n",
-    "print('\\n🦠 Malware Analysis Result:')\n",
-    "print(f'   Prediction: {result.get(\"prediction\", \"N/A\")}')\n",
-    "print(f'   Threat Probability: {result.get(\"threat_probability\", 0):.2%}')\n",
-    "print(f'   Risk Level: {result.get(\"risk_level\", \"N/A\")}')\n",
-    "\n",
-    "print('\\n✅ Inference tests complete!')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "2dee89a6",
-   "metadata": {},
-   "source": [
-    "## 📋 Section 7: Summary and Next Steps\n",
-    "\n",
-    "### ✅ What We Accomplished:\n",
-    "\n",
-    "1. **📥 Dataset Collection**\n",
-    "   - Downloaded 15+ web security datasets\n",
-    "   - Covered phishing, malware, intrusion, web attacks, DNS, spam\n",
-    "   - Combined real-world and synthetic data for comprehensive training\n",
-    "\n",
-    "2. **🔧 Feature Engineering**\n",
-    "   - Domain-specific feature creation\n",
-    "   - Entropy calculations, risk scores, behavioral features\n",
-    "   - Optimized for real-time inference\n",
-    "\n",
-    "3. **🤖 Model Training**\n",
-    "   - Random Forest with class balancing\n",
-    "   - XGBoost with regularization\n",
-    "   - Deep Neural Networks with residual connections\n",
-    "   - Weighted ensemble for maximum accuracy\n",
-    "\n",
-    "4. **🚀 Production Deployment**\n",
-    "   - Unified inference API\n",
-    "   - Multi-domain threat detection\n",
-    "   - Real-time risk assessment\n",
-    "\n",
-    "### 🎯 Integration with Agentic AI:\n",
-    "\n",
-    "The trained models are ready to be integrated with:\n",
-    "- `observation_loop.py` - For real-time browser monitoring\n",
-    "- `action_executor.py` - For automated threat response\n",
-    "- `intelligence_feed.py` - For AI-explained security events\n",
-    "- `scan_modes.py` - For adaptive scanning with ML enhancement\n",
-    "\n",
-    "### 📁 Output Files:\n",
-    "```\n",
-    "models/agentic_security/\n",
-    "├── phishing/\n",
-    "│   ├── random_forest.pkl\n",
-    "│   ├── xgboost.pkl\n",
-    "│   ├── deep_neural_network.keras\n",
-    "│   ├── scaler.pkl\n",
-    "│   └── ensemble_config.pkl\n",
-    "├── malware/\n",
-    "├── intrusion/\n",
-    "├── web_attack/\n",
-    "└── training_metrics.json\n",
-    "```"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "cc806c09",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "print('🎉 Agentic AI Security Training Complete!')\n",
-    "print('\\n📊 Final Summary:')\n",
-    "print(f'   Domains trained: {len(trainer.metrics)}')\n",
-    "print(f'   Total models: {len(trainer.metrics) * 4}')  # 4 models per domain\n",
-    "print(f'   Models directory: {trainer.models_dir}')\n",
-    "\n",
-    "# Best performing models\n",
-    "print('\\n🏆 Best Performing Models (by AUC):')\n",
-    "for domain, models in trainer.metrics.items():\n",
-    "    best_model = max(models.items(), key=lambda x: x[1]['auc'])\n",
-    "    print(f'   {domain}: {best_model[0]} (AUC: {best_model[1][\"auc\"]:.4f})')"
-   ]
-  }
- ],
- "metadata": {
-  "language_info": {
-   "name": "python"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

notebooks/ai_agent_comprehensive_training.ipynb

@@ -1,312 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# 🤖 AI Agent Comprehensive Training Notebook\n",
-    "\n",
-    "## Real-Time Cyber Forge Agentic AI Platform\n",
-    "\n",
-    "This notebook trains an AI agent with:\n",
-    "1. **Communication Skills** - Natural language processing and context understanding\n",
-    "2. **Cybersecurity Expertise** - Threat detection and vulnerability analysis\n",
-    "3. **Web Scraping Capabilities** - Intelligence gathering and IOC extraction\n",
-    "4. **Real-time Integration** - Desktop and mobile app connectivity\n",
-    "\n",
-    "**Author:** Cyber Forge AI Team\n",
-    "**Date:** 2024\n",
-    "\n",
-    "---\n",
-    "\n",
-    "### 🎯 Training Objectives:\n",
-    "- Build conversational AI for cybersecurity communication\n",
-    "- Train threat detection models with high accuracy\n",
-    "- Implement web scraping for threat intelligence\n",
-    "- Create real-time monitoring capabilities\n",
-    "- Deploy models for production integration"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 📦 Package Installation and Setup\n",
-    "\n",
-    "First, let's install all required packages for the AI agent training."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "🚀 Installing required packages...\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "✅ Installed tensorflow>=2.13.0\n",
-      "✅ Installed transformers>=4.30.0\n",
-      "✅ Installed transformers>=4.30.0\n",
-      "✅ Installed torch>=2.0.0\n",
-      "✅ Installed torch>=2.0.0\n",
-      "✅ Installed scikit-learn>=1.3.0\n",
-      "✅ Installed scikit-learn>=1.3.0\n",
-      "✅ Installed pandas>=2.0.0\n",
-      "✅ Installed pandas>=2.0.0\n",
-      "✅ Installed numpy>=1.24.0\n",
-      "✅ Installed numpy>=1.24.0\n",
-      "✅ Installed matplotlib>=3.7.0\n",
-      "✅ Installed matplotlib>=3.7.0\n",
-      "✅ Installed seaborn>=0.12.0\n",
-      "✅ Installed seaborn>=0.12.0\n",
-      "✅ Installed nltk>=3.8.0\n",
-      "✅ Installed nltk>=3.8.0\n",
-      "✅ Installed spacy>=3.6.0\n",
-      "✅ Installed spacy>=3.6.0\n",
-      "✅ Installed beautifulsoup4>=4.12.0\n",
-      "✅ Installed beautifulsoup4>=4.12.0\n",
-      "✅ Installed requests>=2.31.0\n",
-      "✅ Installed requests>=2.31.0\n",
-      "✅ Installed selenium>=4.10.0\n",
-      "✅ Installed selenium>=4.10.0\n",
-      "✅ Installed openai>=0.27.0\n",
-      "✅ Installed openai>=0.27.0\n",
-      "✅ Installed chromadb>=0.4.0\n",
-      "✅ Installed chromadb>=0.4.0\n",
-      "✅ Installed joblib>=1.3.0\n",
-      "🎯 Package installation completed!\n",
-      "✅ Installed joblib>=1.3.0\n",
-      "🎯 Package installation completed!\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Install required packages\n",
-    "import subprocess\n",
-    "import sys\n",
-    "\n",
-    "def install_package(package):\n",
-    "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", package])\n",
-    "\n",
-    "# Core packages for AI training\n",
-    "required_packages = [\n",
-    "    'tensorflow>=2.13.0',\n",
-    "    'transformers>=4.30.0',\n",
-    "    'torch>=2.0.0',\n",
-    "    'scikit-learn>=1.3.0',\n",
-    "    'pandas>=2.0.0',\n",
-    "    'numpy>=1.24.0',\n",
-    "    'matplotlib>=3.7.0',\n",
-    "    'seaborn>=0.12.0',\n",
-    "    'nltk>=3.8.0',\n",
-    "    'spacy>=3.6.0',\n",
-    "    'beautifulsoup4>=4.12.0',\n",
-    "    'requests>=2.31.0',\n",
-    "    'selenium>=4.10.0',\n",
-    "    'openai>=0.27.0',\n",
-    "    'chromadb>=0.4.0',\n",
-    "    'joblib>=1.3.0'\n",
-    "]\n",
-    "\n",
-    "print(\"🚀 Installing required packages...\")\n",
-    "for package in required_packages:\n",
-    "    try:\n",
-    "        install_package(package)\n",
-    "        print(f\"✅ Installed {package}\")\n",
-    "    except Exception as e:\n",
-    "        print(f\"❌ Failed to install {package}: {e}\")\n",
-    "\n",
-    "print(\"🎯 Package installation completed!\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 🗣️ Part 1: Communication Skills Training\n",
-    "\n",
-    "Training the AI agent to communicate effectively about cybersecurity topics."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "✅ Created communication dataset with 30 examples\n",
-      "📊 Context distribution: {'threat_detection': 6, 'user_education': 6, 'incident_response': 6, 'security_briefing': 6, 'emergency_response': 6}\n",
-      "\n",
-      "📋 Sample data:\n",
-      "            context                                              input  \\\n",
-      "0  threat_detection     We detected a potential malware on your system   \n",
-      "1  threat_detection  Variation 1: We detected a potential malware o...   \n",
-      "2  threat_detection  Variation 2: We detected a potential malware o...   \n",
-      "\n",
-      "                      tone  \n",
-      "0  professional_reassuring  \n",
-      "1  professional_reassuring  \n",
-      "2  professional_reassuring  \n",
-      "            context                                              input  \\\n",
-      "0  threat_detection     We detected a potential malware on your system   \n",
-      "1  threat_detection  Variation 1: We detected a potential malware o...   \n",
-      "2  threat_detection  Variation 2: We detected a potential malware o...   \n",
-      "\n",
-      "                      tone  \n",
-      "0  professional_reassuring  \n",
-      "1  professional_reassuring  \n",
-      "2  professional_reassuring  \n"
-     ]
-    }
-   ],
-   "source": [
-    "# Import libraries for communication training\n",
-    "import pandas as pd\n",
-    "import numpy as np\n",
-    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
-    "from sklearn.ensemble import RandomForestClassifier\n",
-    "from sklearn.preprocessing import LabelEncoder\n",
-    "import joblib\n",
-    "import os\n",
-    "\n",
-    "# Create communication training dataset\n",
-    "communication_data = [\n",
-    "    {\n",
-    "        \"context\": \"threat_detection\",\n",
-    "        \"input\": \"We detected a potential malware on your system\",\n",
-    "        \"response\": \"I understand your concern. Let me explain what we found and the recommended actions to secure your system.\",\n",
-    "        \"tone\": \"professional_reassuring\"\n",
-    "    },\n",
-    "    {\n",
-    "        \"context\": \"user_education\",\n",
-    "        \"input\": \"What is phishing?\",\n",
-    "        \"response\": \"Phishing is a cybersecurity attack where criminals impersonate legitimate organizations to steal sensitive information like passwords or credit card numbers.\",\n",
-    "        \"tone\": \"educational_clear\"\n",
-    "    },\n",
-    "    {\n",
-    "        \"context\": \"incident_response\",\n",
-    "        \"input\": \"My computer is acting strange and slow\",\n",
-    "        \"response\": \"That could indicate a security issue. Let's investigate this step by step. First, can you tell me when you first noticed these symptoms?\",\n",
-    "        \"tone\": \"helpful_diagnostic\"\n",
-    "    },\n",
-    "    {\n",
-    "        \"context\": \"security_briefing\",\n",
-    "        \"input\": \"Can you explain our security status?\",\n",
-    "        \"response\": \"Based on our latest analysis, your network shows good security health with no critical threats detected. I've identified a few areas for improvement that I'll detail for you.\",\n",
-    "        \"tone\": \"informative_confident\"\n",
-    "    },\n",
-    "    {\n",
-    "        \"context\": \"emergency_response\",\n",
-    "        \"input\": \"URGENT: Security breach detected!\",  # Added missing input field\n",
-    "        \"response\": \"I understand this is urgent. I'm immediately analyzing your network traffic and will provide you with a real-time security assessment and response plan.\",\n",
-    "        \"tone\": \"calm_urgent\"\n",
-    "    }\n",
-    "]\n",
-    "\n",
-    "# Expand dataset with variations (with better error handling)\n",
-    "expanded_data = []\n",
-    "for item in communication_data:\n",
-    "    expanded_data.append(item)\n",
-    "    # Add variations with different contexts - only if input exists\n",
-    "    if 'input' in item:\n",
-    "        for i in range(5):\n",
-    "            variation = item.copy()\n",
-    "            variation['input'] = f\"Variation {i+1}: {item['input']}\"\n",
-    "            expanded_data.append(variation)\n",
-    "    else:\n",
-    "        print(f\"⚠️ Warning: Item missing 'input' field: {item.get('context', 'Unknown')}\")\n",
-    "\n",
-    "df = pd.DataFrame(expanded_data)\n",
-    "print(f\"✅ Created communication dataset with {len(df)} examples\")\n",
-    "print(f\"📊 Context distribution: {df['context'].value_counts().to_dict()}\")\n",
-    "\n",
-    "# Display sample data\n",
-    "print(f\"\\n📋 Sample data:\")\n",
-    "print(df[['context', 'input', 'tone']].head(3))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "🎯 Training communication classifier...\n",
-      "✅ Communication models trained and saved!\n",
-      "📍 Models saved in: ../models/communication/\n",
-      "✅ Communication models trained and saved!\n",
-      "📍 Models saved in: ../models/communication/\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Train communication models\n",
-    "print(\"🎯 Training communication classifier...\")\n",
-    "\n",
-    "# Prepare features\n",
-    "vectorizer = TfidfVectorizer(max_features=1000, stop_words='english')\n",
-    "X = vectorizer.fit_transform(df['input'])\n",
-    "\n",
-    "# Encode labels\n",
-    "context_encoder = LabelEncoder()\n",
-    "tone_encoder = LabelEncoder()\n",
-    "\n",
-    "y_context = context_encoder.fit_transform(df['context'])\n",
-    "y_tone = tone_encoder.fit_transform(df['tone'])\n",
-    "\n",
-    "# Train models\n",
-    "context_model = RandomForestClassifier(n_estimators=100, random_state=42)\n",
-    "tone_model = RandomForestClassifier(n_estimators=100, random_state=42)\n",
-    "\n",
-    "context_model.fit(X, y_context)\n",
-    "tone_model.fit(X, y_tone)\n",
-    "\n",
-    "# Save models\n",
-    "os.makedirs('../models/communication', exist_ok=True)\n",
-    "joblib.dump(vectorizer, '../models/communication/vectorizer.pkl')\n",
-    "joblib.dump(context_model, '../models/communication/context_classifier.pkl')\n",
-    "joblib.dump(tone_model, '../models/communication/tone_classifier.pkl')\n",
-    "joblib.dump(context_encoder, '../models/communication/context_encoder.pkl')\n",
-    "joblib.dump(tone_encoder, '../models/communication/tone_encoder.pkl')\n",
-    "\n",
-    "print(\"✅ Communication models trained and saved!\")\n",
-    "print(f\"📍 Models saved in: ../models/communication/\")"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": ".venv",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.15.0"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}

notebooks/ai_agent_training.py

@@ -1,911 +0,0 @@
-#!/usr/bin/env python3
-"""
-AI Agent Comprehensive Training Notebook
-========================================
-
-This notebook trains an AI agent with:
-1. Communication skills
-2. Cybersecurity expertise  
-3. Web scraping capabilities
-4. Real-time threat detection
-5. Natural language processing for security analysis
-
-Author: Cyber Forge AI Team
-Date: 2024
-"""
-
-# Install required packages
-import subprocess
-import sys
-
-def install_package(package):
-    subprocess.check_call([sys.executable, "-m", "pip", "install", package])
-
-# Core packages
-required_packages = [
-    'tensorflow>=2.13.0',
-    'transformers>=4.30.0',
-    'torch>=2.0.0',
-    'scikit-learn>=1.3.0',
-    'pandas>=2.0.0',
-    'numpy>=1.24.0',
-    'matplotlib>=3.7.0',
-    'seaborn>=0.12.0',
-    'nltk>=3.8.0',
-    'spacy>=3.6.0',
-    'beautifulsoup4>=4.12.0',
-    'requests>=2.31.0',
-    'selenium>=4.10.0',
-    'scrapy>=2.9.0',
-    'langchain>=0.0.200',
-    'chromadb>=0.4.0',
-    'faiss-cpu>=1.7.4',
-    'huggingface_hub>=0.16.0',
-    'sentence-transformers>=2.2.2',
-    'accelerate>=0.20.0',
-    'joblib>=1.3.0'
-]
-
-print("🚀 Installing required packages...")
-for package in required_packages:
-    try:
-        install_package(package)
-        print(f"✅ Installed {package}")
-    except Exception as e:
-        print(f"❌ Failed to install {package}: {e}")
-
-# Import core libraries
-import os
-import json
-import pickle
-import joblib
-from datetime import datetime
-import warnings
-warnings.filterwarnings('ignore')
-
-import numpy as np
-import pandas as pd
-import matplotlib.pyplot as plt
-import seaborn as sns
-
-from sklearn.model_selection import train_test_split, cross_val_score
-from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
-from sklearn.linear_model import LogisticRegression
-from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score
-from sklearn.preprocessing import StandardScaler, LabelEncoder
-from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
-
-import tensorflow as tf
-from tensorflow.keras.models import Sequential, Model
-from tensorflow.keras.layers import Dense, LSTM, Embedding, Dropout, Attention
-from tensorflow.keras.optimizers import Adam
-from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
-
-import torch
-import torch.nn as nn
-from transformers import (
-    AutoTokenizer, AutoModel, AutoModelForSequenceClassification,
-    TrainingArguments, Trainer, pipeline
-)
-
-import nltk
-import spacy
-from nltk.corpus import stopwords
-from nltk.tokenize import word_tokenize, sent_tokenize
-from nltk.stem import WordNetLemmatizer
-
-import requests
-from bs4 import BeautifulSoup
-from selenium import webdriver
-from selenium.webdriver.chrome.options import Options
-from selenium.webdriver.common.by import By
-
-print("📚 All packages imported successfully!")
-
-# Download required NLTK data
-print("📥 Downloading NLTK data...")
-nltk.download('punkt', quiet=True)
-nltk.download('stopwords', quiet=True)
-nltk.download('wordnet', quiet=True)
-nltk.download('averaged_perceptron_tagger', quiet=True)
-
-# Load spaCy model
-print("🔧 Loading spaCy model...")
-try:
-    nlp = spacy.load('en_core_web_sm')
-except OSError:
-    print("Installing spaCy English model...")
-    subprocess.run([sys.executable, "-m", "spacy", "download", "en_core_web_sm"])
-    nlp = spacy.load('en_core_web_sm')
-
-print("🎯 Setup completed! Ready for AI Agent training...")
-
-# =============================================================================
-# PART 1: COMMUNICATION SKILLS TRAINING
-# =============================================================================
-
-print("\n" + "="*60)
-print("🗣️  PART 1: COMMUNICATION SKILLS TRAINING")
-print("="*60)
-
-class CommunicationSkillsTrainer:
-    def __init__(self):
-        self.tokenizer = None
-        self.model = None
-        self.conversation_history = []
-        
-    def load_pretrained_model(self):
-        """Load a pretrained conversational AI model"""
-        print("📥 Loading conversational AI model...")
-        model_name = "microsoft/DialoGPT-medium"
-        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
-        self.model = AutoModel.from_pretrained(model_name)
-        print("✅ Conversational model loaded!")
-        
-    def create_communication_dataset(self):
-        """Create a dataset for communication training"""
-        print("📊 Creating communication training dataset...")
-        
-        # Cybersecurity communication scenarios
-        communication_data = [
-            {
-                "context": "threat_detection",
-                "input": "We detected a potential malware on your system",
-                "response": "I understand your concern. Let me explain what we found and the recommended actions to secure your system.",
-                "tone": "professional_reassuring"
-            },
-            {
-                "context": "user_education",
-                "input": "What is phishing?",
-                "response": "Phishing is a cybersecurity attack where criminals impersonate legitimate organizations to steal sensitive information like passwords or credit card numbers.",
-                "tone": "educational_clear"
-            },
-            {
-                "context": "incident_response",
-                "input": "My computer is acting strange and slow",
-                "response": "That could indicate a security issue. Let's investigate this step by step. First, can you tell me when you first noticed these symptoms?",
-                "tone": "helpful_diagnostic"
-            },
-            {
-                "context": "security_briefing",
-                "input": "Can you explain our security status?",
-                "response": "Based on our latest analysis, your network shows good security health with no critical threats detected. I've identified a few areas for improvement that I'll detail for you.",
-                "tone": "informative_confident"
-            },
-            {
-                "context": "emergency_response",
-                "input": "We think we're under attack!",
-                "response": "I understand this is urgent. I'm immediately analyzing your network traffic and will provide you with a real-time security assessment and response plan.",
-                "tone": "calm_urgent"
-            }
-        ]
-        
-        # Expand dataset with variations
-        expanded_data = []
-        for item in communication_data:
-            expanded_data.append(item)
-            # Add variations with different tones and contexts
-            for i in range(3):
-                variation = item.copy()
-                variation['input'] = f"Variation {i+1}: {item['input']}"
-                expanded_data.append(variation)
-        
-        df = pd.DataFrame(expanded_data)
-        print(f"✅ Created communication dataset with {len(df)} examples")
-        return df
-    
-    def train_communication_classifier(self, df):
-        """Train a model to classify communication contexts and tones"""
-        print("🎯 Training communication classifier...")
-        
-        # Prepare features
-        vectorizer = TfidfVectorizer(max_features=1000, stop_words='english')
-        X = vectorizer.fit_transform(df['input'])
-        
-        # Encode labels
-        context_encoder = LabelEncoder()
-        tone_encoder = LabelEncoder()
-        
-        y_context = context_encoder.fit_transform(df['context'])
-        y_tone = tone_encoder.fit_transform(df['tone'])
-        
-        # Train models
-        context_model = RandomForestClassifier(n_estimators=100, random_state=42)
-        tone_model = RandomForestClassifier(n_estimators=100, random_state=42)
-        
-        context_model.fit(X, y_context)
-        tone_model.fit(X, y_tone)
-        
-        # Save models
-        os.makedirs('../models/communication', exist_ok=True)
-        joblib.dump(vectorizer, '../models/communication/vectorizer.pkl')
-        joblib.dump(context_model, '../models/communication/context_classifier.pkl')
-        joblib.dump(tone_model, '../models/communication/tone_classifier.pkl')
-        joblib.dump(context_encoder, '../models/communication/context_encoder.pkl')
-        joblib.dump(tone_encoder, '../models/communication/tone_encoder.pkl')
-        
-        print("✅ Communication classifier trained and saved!")
-        return context_model, tone_model, vectorizer
-    
-    def generate_response(self, user_input, context_model, tone_model, vectorizer):
-        """Generate appropriate response based on context and tone"""
-        # Vectorize input
-        input_vector = vectorizer.transform([user_input])
-        
-        # Predict context and tone
-        predicted_context = context_model.predict(input_vector)[0]
-        predicted_tone = tone_model.predict(input_vector)[0]
-        
-        # Generate response (simplified - in production would use advanced NLG)
-        response_templates = {
-            0: "I understand your security concern. Let me analyze this and provide you with a detailed assessment.",
-            1: "That's a great question about cybersecurity. Let me explain that in detail.",
-            2: "I see there might be a security issue. Let's investigate this systematically.",
-            3: "Based on my analysis, here's your current security status and recommendations.",
-            4: "I'm detecting this as a potential security incident. Let me provide immediate assistance."
-        }
-        
-        response = response_templates.get(predicted_context, "I'm here to help with your cybersecurity needs.")
-        return response, predicted_context, predicted_tone
-
-# Initialize and train communication skills
-comm_trainer = CommunicationSkillsTrainer()
-comm_trainer.load_pretrained_model()
-comm_df = comm_trainer.create_communication_dataset()
-context_model, tone_model, vectorizer = comm_trainer.train_communication_classifier(comm_df)
-
-# Test communication skills
-test_inputs = [
-    "Is my password secure?",
-    "I think someone hacked my email",
-    "What should I do about this virus warning?"
-]
-
-print("\n🧪 Testing Communication Skills:")
-for test_input in test_inputs:
-    response, context, tone = comm_trainer.generate_response(test_input, context_model, tone_model, vectorizer)
-    print(f"Input: {test_input}")
-    print(f"Response: {response}")
-    print(f"Context: {context}, Tone: {tone}\n")
-
-# =============================================================================
-# PART 2: CYBERSECURITY EXPERTISE TRAINING
-# =============================================================================
-
-print("\n" + "="*60)
-print("🛡️  PART 2: CYBERSECURITY EXPERTISE TRAINING")
-print("="*60)
-
-class CybersecurityExpertiseTrainer:
-    def __init__(self):
-        self.threat_classifier = None
-        self.vulnerability_detector = None
-        self.attack_predictor = None
-        
-    def create_cybersecurity_dataset(self):
-        """Create comprehensive cybersecurity training dataset"""
-        print("📊 Creating cybersecurity expertise dataset...")
-        
-        # Threat indicators dataset
-        threat_data = {
-            'network_traffic': [
-                'SYN flood detected on port 80',
-                'Multiple failed SSH login attempts',
-                'Unusual outbound traffic to unknown IPs',
-                'DNS tunneling patterns detected',
-                'Bandwidth spike indicating DDoS'
-            ],
-            'malware_signatures': [
-                'Suspicious executable with packed sections',
-                'File with known malicious hash signature',
-                'Process injection techniques detected',
-                'Registry modifications matching trojan behavior',
-                'Encrypted communication to C&C server'
-            ],
-            'phishing_indicators': [
-                'Email with suspicious sender domain',
-                'Link pointing to IP address instead of domain',
-                'Urgent language requesting credential update',
-                'Attachment with double extension',
-                'Spoofed header information'
-            ],
-            'vulnerability_signs': [
-                'Unpatched software version detected',
-                'Default credentials still in use',
-                'Open ports with unnecessary services',
-                'Weak encryption algorithms in use',
-                'SQL injection attack vectors found'
-            ]
-        }
-        
-        # Create labeled dataset
-        dataset = []
-        for category, indicators in threat_data.items():
-            for indicator in indicators:
-                dataset.append({
-                    'indicator': indicator,
-                    'threat_type': category,
-                    'severity': np.random.choice(['low', 'medium', 'high', 'critical']),
-                    'confidence': np.random.uniform(0.7, 0.99)
-                })
-        
-        # Add benign samples
-        benign_indicators = [
-            'Normal HTTP traffic patterns',
-            'Scheduled system updates detected',
-            'User authentication successful',
-            'Regular backup processes running',
-            'Standard business application usage'
-        ]
-        
-        for indicator in benign_indicators:
-            dataset.append({
-                'indicator': indicator,
-                'threat_type': 'benign',
-                'severity': 'none',
-                'confidence': np.random.uniform(0.8, 0.95)
-            })
-        
-        df = pd.DataFrame(dataset)
-        print(f"✅ Created cybersecurity dataset with {len(df)} samples")
-        return df
-    
-    def train_threat_detection_models(self, df):
-        """Train various threat detection models"""
-        print("🎯 Training threat detection models...")
-        
-        # Prepare features
-        vectorizer = TfidfVectorizer(max_features=1000, ngram_range=(1, 2))
-        X = vectorizer.fit_transform(df['indicator'])
-        
-        # Encode labels
-        threat_encoder = LabelEncoder()
-        severity_encoder = LabelEncoder()
-        
-        y_threat = threat_encoder.fit_transform(df['threat_type'])
-        y_severity = severity_encoder.fit_transform(df['severity'])
-        
-        # Split data
-        X_train, X_test, y_threat_train, y_threat_test = train_test_split(
-            X, y_threat, test_size=0.2, random_state=42
-        )
-        
-        # Train multiple models
-        models = {
-            'random_forest': RandomForestClassifier(n_estimators=200, random_state=42),
-            'gradient_boost': GradientBoostingClassifier(n_estimators=100, random_state=42),
-            'logistic_regression': LogisticRegression(random_state=42, max_iter=1000)
-        }
-        
-        trained_models = {}
-        for name, model in models.items():
-            print(f"Training {name}...")
-            model.fit(X_train, y_threat_train)
-            
-            # Evaluate
-            y_pred = model.predict(X_test)
-            accuracy = model.score(X_test, y_threat_test)
-            print(f"{name} accuracy: {accuracy:.3f}")
-            
-            trained_models[name] = model
-        
-        # Save models
-        os.makedirs('../models/cybersecurity', exist_ok=True)
-        joblib.dump(vectorizer, '../models/cybersecurity/threat_vectorizer.pkl')
-        joblib.dump(trained_models, '../models/cybersecurity/threat_models.pkl')
-        joblib.dump(threat_encoder, '../models/cybersecurity/threat_encoder.pkl')
-        joblib.dump(severity_encoder, '../models/cybersecurity/severity_encoder.pkl')
-        
-        print("✅ Threat detection models trained and saved!")
-        return trained_models, vectorizer, threat_encoder
-    
-    def create_advanced_neural_model(self):
-        """Create advanced neural network for complex threat patterns"""
-        print("🧠 Creating advanced neural threat detection model...")
-        
-        model = Sequential([
-            Dense(512, activation='relu', input_shape=(1000,)),
-            Dropout(0.3),
-            Dense(256, activation='relu'),
-            Dropout(0.3),
-            Dense(128, activation='relu'),
-            Dropout(0.2),
-            Dense(64, activation='relu'),
-            Dense(5, activation='softmax')  # 5 threat categories
-        ])
-        
-        model.compile(
-            optimizer=Adam(learning_rate=0.001),
-            loss='sparse_categorical_crossentropy',
-            metrics=['accuracy']
-        )
-        
-        print("✅ Advanced neural model created!")
-        return model
-
-# Initialize and train cybersecurity expertise
-cyber_trainer = CybersecurityExpertiseTrainer()
-cyber_df = cyber_trainer.create_cybersecurity_dataset()
-threat_models, threat_vectorizer, threat_encoder = cyber_trainer.train_threat_detection_models(cyber_df)
-neural_model = cyber_trainer.create_advanced_neural_model()
-
-# Test cybersecurity expertise
-test_threats = [
-    "Multiple failed login attempts from foreign IP",
-    "Suspicious PowerShell execution detected",
-    "Regular software update process running"
-]
-
-print("\n🧪 Testing Cybersecurity Expertise:")
-for test_threat in test_threats:
-    threat_vector = threat_vectorizer.transform([test_threat])
-    
-    for model_name, model in threat_models.items():
-        prediction = model.predict(threat_vector)[0]
-        threat_type = threat_encoder.inverse_transform([prediction])[0]
-        confidence = max(model.predict_proba(threat_vector)[0])
-        
-        print(f"Threat: {test_threat}")
-        print(f"Model: {model_name}")
-        print(f"Prediction: {threat_type} (confidence: {confidence:.3f})\n")
-
-# =============================================================================
-# PART 3: WEB SCRAPING CAPABILITIES
-# =============================================================================
-
-print("\n" + "="*60)
-print("🕷️  PART 3: WEB SCRAPING CAPABILITIES")
-print("="*60)
-
-class WebScrapingAgent:
-    def __init__(self):
-        self.session = requests.Session()
-        self.session.headers.update({
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
-        })
-        
-    def setup_selenium_driver(self):
-        """Setup Selenium WebDriver for dynamic content"""
-        print("🚗 Setting up Selenium WebDriver...")
-        
-        chrome_options = Options()
-        chrome_options.add_argument('--headless')
-        chrome_options.add_argument('--no-sandbox')
-        chrome_options.add_argument('--disable-dev-shm-usage')
-        chrome_options.add_argument('--disable-gpu')
-        
-        try:
-            driver = webdriver.Chrome(options=chrome_options)
-            print("✅ Selenium WebDriver ready!")
-            return driver
-        except Exception as e:
-            print(f"❌ WebDriver setup failed: {e}")
-            return None
-    
-    def scrape_threat_intelligence(self, urls):
-        """Scrape threat intelligence from security websites"""
-        print("🔍 Scraping threat intelligence...")
-        
-        threat_data = []
-        
-        for url in urls:
-            try:
-                response = self.session.get(url, timeout=10)
-                if response.status_code == 200:
-                    soup = BeautifulSoup(response.content, 'html.parser')
-                    
-                    # Extract relevant security information
-                    title = soup.find('title')
-                    headers = soup.find_all(['h1', 'h2', 'h3'])
-                    paragraphs = soup.find_all('p')
-                    
-                    content = {
-                        'url': url,
-                        'title': title.text.strip() if title else '',
-                        'headers': [h.text.strip() for h in headers[:5]],
-                        'content': [p.text.strip() for p in paragraphs[:10] if len(p.text.strip()) > 50]
-                    }
-                    
-                    threat_data.append(content)
-                    print(f"✅ Scraped: {url}")
-                    
-            except Exception as e:
-                print(f"❌ Failed to scrape {url}: {e}")
-        
-        return threat_data
-    
-    def extract_iocs(self, text):
-        """Extract Indicators of Compromise from text"""
-        import re
-        
-        iocs = {
-            'ip_addresses': re.findall(r'\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b', text),
-            'domains': re.findall(r'\b[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*\b', text),
-            'email_addresses': re.findall(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', text),
-            'file_hashes': re.findall(r'\b[a-fA-F0-9]{32}\b|\b[a-fA-F0-9]{40}\b|\b[a-fA-F0-9]{64}\b', text),
-            'urls': re.findall(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', text)
-        }
-        
-        return iocs
-    
-    def analyze_scraped_content(self, threat_data):
-        """Analyze scraped content for security insights"""
-        print("📊 Analyzing scraped content...")
-        
-        analysis_results = []
-        
-        for data in threat_data:
-            all_text = ' '.join([data['title']] + data['headers'] + data['content'])
-            
-            # Extract IOCs
-            iocs = self.extract_iocs(all_text)
-            
-            # Security keyword analysis
-            security_keywords = [
-                'malware', 'phishing', 'ransomware', 'trojan', 'virus',
-                'exploit', 'vulnerability', 'breach', 'attack', 'threat'
-            ]
-            
-            keyword_count = sum(all_text.lower().count(keyword) for keyword in security_keywords)
-            
-            analysis = {
-                'url': data['url'],
-                'security_relevance': keyword_count,
-                'iocs_found': sum(len(ioc_list) for ioc_list in iocs.values()),
-                'iocs': iocs,
-                'summary': data['title']
-            }
-            
-            analysis_results.append(analysis)
-        
-        print(f"✅ Analyzed {len(analysis_results)} sources")
-        return analysis_results
-
-# Initialize web scraping agent
-scraper = WebScrapingAgent()
-
-# Example threat intelligence sources (using safe examples)
-sample_urls = [
-    'https://example.com',  # Replace with actual threat intelligence sources
-    'https://httpbin.org/html'  # Safe test URL
-]
-
-# Demonstrate web scraping capabilities
-print("🧪 Testing Web Scraping Capabilities:")
-threat_intel = scraper.scrape_threat_intelligence(sample_urls)
-analysis = scraper.analyze_scraped_content(threat_intel)
-
-for result in analysis:
-    print(f"URL: {result['url']}")
-    print(f"Security Relevance Score: {result['security_relevance']}")
-    print(f"IOCs Found: {result['iocs_found']}")
-    print("---")
-
-# =============================================================================
-# PART 4: INTEGRATED AI AGENT ASSEMBLY
-# =============================================================================
-
-print("\n" + "="*60)
-print("🤖 PART 4: INTEGRATED AI AGENT ASSEMBLY")
-print("="*60)
-
-class CyberForgeAIAgent:
-    def __init__(self):
-        self.communication_models = None
-        self.cybersecurity_models = None
-        self.web_scraper = None
-        self.knowledge_base = {}
-        
-    def load_all_models(self):
-        """Load all trained models and components"""
-        print("📥 Loading all AI models and components...")
-        
-        try:
-            # Load communication models
-            self.communication_models = {
-                'vectorizer': joblib.load('../models/communication/vectorizer.pkl'),
-                'context_classifier': joblib.load('../models/communication/context_classifier.pkl'),
-                'tone_classifier': joblib.load('../models/communication/tone_classifier.pkl')
-            }
-            
-            # Load cybersecurity models
-            self.cybersecurity_models = {
-                'vectorizer': joblib.load('../models/cybersecurity/threat_vectorizer.pkl'),
-                'models': joblib.load('../models/cybersecurity/threat_models.pkl'),
-                'encoder': joblib.load('../models/cybersecurity/threat_encoder.pkl')
-            }
-            
-            # Initialize web scraper
-            self.web_scraper = WebScrapingAgent()
-            
-            print("✅ All models loaded successfully!")
-            
-        except FileNotFoundError as e:
-            print(f"❌ Model loading failed: {e}")
-            print("Please ensure all models are trained and saved first.")
-    
-    def process_security_query(self, query, context="general"):
-        """Process a security-related query using all capabilities"""
-        print(f"🔍 Processing query: {query}")
-        
-        response = {
-            'original_query': query,
-            'context': context,
-            'threat_analysis': None,
-            'recommendations': [],
-            'confidence': 0.0,
-            'response_text': ''
-        }
-        
-        try:
-            # Analyze with cybersecurity models
-            if self.cybersecurity_models:
-                query_vector = self.cybersecurity_models['vectorizer'].transform([query])
-                
-                # Get predictions from all models
-                predictions = {}
-                for model_name, model in self.cybersecurity_models['models'].items():
-                    pred = model.predict(query_vector)[0]
-                    prob = max(model.predict_proba(query_vector)[0])
-                    threat_type = self.cybersecurity_models['encoder'].inverse_transform([pred])[0]
-                    
-                    predictions[model_name] = {
-                        'threat_type': threat_type,
-                        'confidence': prob
-                    }
-                
-                response['threat_analysis'] = predictions
-            
-            # Generate communication response
-            if self.communication_models:
-                query_vector = self.communication_models['vectorizer'].transform([query])
-                context_pred = self.communication_models['context_classifier'].predict(query_vector)[0]
-                tone_pred = self.communication_models['tone_classifier'].predict(query_vector)[0]
-                
-                # Generate appropriate response
-                if 'malware' in query.lower() or 'virus' in query.lower():
-                    response['response_text'] = "I've detected potential malware indicators in your query. Let me analyze this threat and provide you with specific recommendations for mitigation."
-                elif 'phishing' in query.lower():
-                    response['response_text'] = "This appears to be related to phishing threats. I'll help you identify the indicators and protect against similar attacks."
-                elif 'attack' in query.lower():
-                    response['response_text'] = "I'm analyzing this potential security attack. Let me provide you with immediate response recommendations and protective measures."
-                else:
-                    response['response_text'] = "I'm analyzing your security concern using my trained models. Let me provide you with a comprehensive assessment."
-            
-            # Generate recommendations based on analysis
-            if response['threat_analysis']:
-                avg_confidence = np.mean([pred['confidence'] for pred in response['threat_analysis'].values()])
-                response['confidence'] = avg_confidence
-                
-                if avg_confidence > 0.8:
-                    response['recommendations'] = [
-                        "Immediate investigation recommended",
-                        "Implement enhanced monitoring",
-                        "Consider threat containment measures",
-                        "Update security protocols"
-                    ]
-                elif avg_confidence > 0.6:
-                    response['recommendations'] = [
-                        "Monitor situation closely",
-                        "Review security logs",
-                        "Consider preventive measures"
-                    ]
-                else:
-                    response['recommendations'] = [
-                        "Continue normal monitoring",
-                        "Document for future reference"
-                    ]
-            
-        except Exception as e:
-            print(f"❌ Error processing query: {e}")
-            response['response_text'] = "I encountered an error while processing your query. Please try again or rephrase your question."
-        
-        return response
-    
-    def continuous_learning_update(self, feedback_data):
-        """Update models based on user feedback"""
-        print("📚 Updating models with new feedback...")
-        
-        # In production, this would retrain models with new data
-        # For now, we'll simulate the update process
-        self.knowledge_base['last_update'] = datetime.now()
-        self.knowledge_base['feedback_count'] = self.knowledge_base.get('feedback_count', 0) + 1
-        
-        print(f"✅ Knowledge base updated! Total feedback: {self.knowledge_base['feedback_count']}")
-    
-    def generate_security_report(self, time_period="24h"):
-        """Generate a comprehensive security report"""
-        print(f"📊 Generating security report for {time_period}...")
-        
-        report = {
-            'timestamp': datetime.now().isoformat(),
-            'period': time_period,
-            'summary': {
-                'total_queries': np.random.randint(50, 200),
-                'threats_detected': np.random.randint(5, 25),
-                'false_positives': np.random.randint(1, 8),
-                'accuracy': np.random.uniform(0.85, 0.98)
-            },
-            'threat_categories': {
-                'malware': np.random.randint(2, 10),
-                'phishing': np.random.randint(1, 8),
-                'network_intrusion': np.random.randint(0, 5),
-                'vulnerability': np.random.randint(3, 12)
-            },
-            'recommendations': [
-                "Continue monitoring current threat landscape",
-                "Update threat detection signatures",
-                "Review and update security policies",
-                "Consider additional training for security team"
-            ]
-        }
-        
-        print("✅ Security report generated!")
-        return report
-
-# Initialize the complete AI agent
-print("🚀 Initializing Cyber Forge AI Agent...")
-ai_agent = CyberForgeAIAgent()
-ai_agent.load_all_models()
-
-# Test the integrated AI agent
-test_queries = [
-    "I think there's malware on my computer",
-    "Can you explain what a DDoS attack is?",
-    "We're seeing unusual network traffic",
-    "Help me understand this security alert"
-]
-
-print("\n🧪 Testing Integrated AI Agent:")
-for query in test_queries:
-    response = ai_agent.process_security_query(query)
-    print(f"\nQuery: {query}")
-    print(f"Response: {response['response_text']}")
-    print(f"Confidence: {response['confidence']:.3f}")
-    if response['recommendations']:
-        print("Recommendations:")
-        for rec in response['recommendations']:
-            print(f"  - {rec}")
-    print("-" * 50)
-
-# Generate sample security report
-security_report = ai_agent.generate_security_report()
-print(f"\n📊 Sample Security Report:")
-print(f"Period: {security_report['period']}")
-print(f"Total Queries: {security_report['summary']['total_queries']}")
-print(f"Threats Detected: {security_report['summary']['threats_detected']}")
-print(f"Overall Accuracy: {security_report['summary']['accuracy']:.3f}")
-
-# =============================================================================
-# PART 5: DEPLOYMENT AND INTEGRATION
-# =============================================================================
-
-print("\n" + "="*60)
-print("🚀 PART 5: DEPLOYMENT AND INTEGRATION")
-print("="*60)
-
-class AIAgentDeployment:
-    def __init__(self, ai_agent):
-        self.ai_agent = ai_agent
-        
-    def create_api_interface(self):
-        """Create API interface for the AI agent"""
-        print("🔌 Creating API interface...")
-        
-        api_specs = {
-            'endpoints': {
-                '/analyze': {
-                    'method': 'POST',
-                    'description': 'Analyze security query or threat',
-                    'parameters': ['query', 'context'],
-                    'response': 'threat_analysis and recommendations'
-                },
-                '/scrape': {
-                    'method': 'POST',
-                    'description': 'Scrape threat intelligence from URLs',
-                    'parameters': ['urls'],
-                    'response': 'scraped_data and analysis'
-                },
-                '/report': {
-                    'method': 'GET',
-                    'description': 'Generate security report',
-                    'parameters': ['time_period'],
-                    'response': 'comprehensive_security_report'
-                },
-                '/feedback': {
-                    'method': 'POST',
-                    'description': 'Submit feedback for model improvement',
-                    'parameters': ['query', 'feedback', 'rating'],
-                    'response': 'acknowledgment'
-                }
-            }
-        }
-        
-        print("✅ API interface specifications created!")
-        return api_specs
-    
-    def create_integration_guide(self):
-        """Create integration guide for desktop and mobile apps"""
-        print("📖 Creating integration guide...")
-        
-        integration_guide = {
-            'desktop_integration': {
-                'websocket_events': [
-                    'ai_query_request',
-                    'ai_response_ready',
-                    'threat_analysis_complete',
-                    'real_time_monitoring_update'
-                ],
-                'data_flow': [
-                    'Desktop captures browsing data',
-                    'AI agent analyzes for threats',
-                    'Results sent back to desktop',
-                    'User receives real-time alerts'
-                ]
-            },
-            'mobile_integration': {
-                'api_calls': [
-                    'GET /api/ai/status',
-                    'POST /api/ai/analyze',
-                    'GET /api/ai/reports',
-                    'POST /api/ai/feedback'
-                ],
-                'features': [
-                    'Real-time threat notifications',
-                    'Security status dashboard',
-                    'AI-powered recommendations',
-                    'Threat intelligence feeds'
-                ]
-            }
-        }
-        
-        print("✅ Integration guide created!")
-        return integration_guide
-    
-    def save_deployment_artifacts(self):
-        """Save all deployment artifacts"""
-        print("💾 Saving deployment artifacts...")
-        
-        deployment_info = {
-            'ai_agent_version': '1.0.0',
-            'models_trained': [
-                'communication_classifier',
-                'threat_detection_ensemble',
-                'neural_threat_analyzer'
-            ],
-            'capabilities': [
-                'Natural language communication',
-                'Threat detection and analysis',
-                'Web scraping and intelligence gathering',
-                'Real-time monitoring',
-                'Automated reporting'
-            ],
-            'deployment_ready': True,
-            'last_trained': datetime.now().isoformat()
-        }
-        
-        # Save deployment configuration
-        os.makedirs('../models/deployment', exist_ok=True)
-        with open('../models/deployment/deployment_config.json', 'w') as f:
-            json.dump(deployment_info, f, indent=2)
-        
-        print("✅ Deployment artifacts saved!")
-        return deployment_info
-
-# Create deployment package
-deployment = AIAgentDeployment(ai_agent)
-api_specs = deployment.create_api_interface()
-integration_guide = deployment.create_integration_guide()
-deployment_info = deployment.save_deployment_artifacts()
-
-print("🎉 AI Agent training and deployment preparation complete!")
-print("\n📋 Training Summary:")
-print("✅ Communication skills: Trained with conversational AI and context classification")
-print("✅ Cybersecurity expertise: Trained with threat detection and vulnerability analysis")
-print("✅ Web scraping capabilities: Implemented with BeautifulSoup and Selenium")
-print("✅ Integration ready: API specifications and deployment artifacts created")
-print("✅ Real-time monitoring: WebSocket integration for live threat detection")
-
-print(f"\n🔧 Models saved in: ../models/")
-print("📊 Ready for integration with desktop and mobile applications!")
-print("🚀 AI Agent is production-ready for the Cyber Forge platform!")

notebooks/enhanced_cybersecurity_ml_training.ipynb

@@ -1,1041 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Enhanced Cybersecurity ML Training - Advanced Threat Detection\n",
-    "\n",
-    "This notebook implements state-of-the-art machine learning techniques for cybersecurity threat detection, including:\n",
-    "- Deep learning models for malware detection\n",
-    "- Anomaly detection for network traffic\n",
-    "- Real-time threat scoring\n",
-    "- Advanced feature engineering\n",
-    "- Model interpretability and explainability\n",
-    "\n",
-    "**Author:** Cyber Forge AI Team  \n",
-    "**Last Updated:** 2024  \n",
-    "**Version:** 2.0"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 1. Environment Setup and Imports"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import os\n",
-    "import sys\n",
-    "import warnings\n",
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "import matplotlib.pyplot as plt\n",
-    "import seaborn as sns\n",
-    "import plotly.graph_objects as go\n",
-    "import plotly.express as px\n",
-    "from plotly.subplots import make_subplots\n",
-    "\n",
-    "# Machine Learning libraries\n",
-    "from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV\n",
-    "from sklearn.preprocessing import StandardScaler, LabelEncoder, MinMaxScaler\n",
-    "from sklearn.ensemble import RandomForestClassifier, IsolationForest, GradientBoostingClassifier\n",
-    "from sklearn.linear_model import LogisticRegression\n",
-    "from sklearn.svm import SVC\n",
-    "from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score, roc_curve\n",
-    "from sklearn.feature_selection import SelectKBest, f_classif\n",
-    "from sklearn.decomposition import PCA\n",
-    "from sklearn.cluster import DBSCAN, KMeans\n",
-    "\n",
-    "# Deep Learning\n",
-    "import tensorflow as tf\n",
-    "from tensorflow.keras.models import Sequential, Model\n",
-    "from tensorflow.keras.layers import Dense, Dropout, LSTM, Conv1D, MaxPooling1D, Flatten\n",
-    "from tensorflow.keras.layers import Input, Embedding, GlobalMaxPooling1D\n",
-    "from tensorflow.keras.optimizers import Adam\n",
-    "from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau\n",
-    "\n",
-    "# XGBoost\n",
-    "import xgboost as xgb\n",
-    "\n",
-    "# Additional utilities\n",
-    "from datetime import datetime\n",
-    "import joblib\n",
-    "import json\n",
-    "import hashlib\n",
-    "import ipaddress\n",
-    "import re\n",
-    "from collections import Counter\n",
-    "import time\n",
-    "\n",
-    "# Suppress warnings\n",
-    "warnings.filterwarnings('ignore')\n",
-    "os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'\n",
-    "\n",
-    "# Set random seeds for reproducibility\n",
-    "np.random.seed(42)\n",
-    "tf.random.set_seed(42)\n",
-    "\n",
-    "print(\"✅ Environment setup complete\")\n",
-    "print(f\"TensorFlow version: {tf.__version__}\")\n",
-    "print(f\"Scikit-learn version: {sklearn.__version__}\")\n",
-    "print(f\"Pandas version: {pd.__version__}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 2. Advanced Data Generation and Feature Engineering"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class CybersecurityDataGenerator:\n",
-    "    \"\"\"Enhanced cybersecurity data generator with realistic threat patterns.\"\"\"\n",
-    "    \n",
-    "    def __init__(self, seed=42):\n",
-    "        np.random.seed(seed)\n",
-    "        self.attack_signatures = {\n",
-    "            'ddos': {'packet_rate': (1000, 10000), 'connection_duration': (0.1, 2)},\n",
-    "            'malware': {'file_entropy': (7.5, 8.0), 'suspicious_imports': (5, 20)},\n",
-    "            'phishing': {'domain_age': (0, 30), 'ssl_suspicious': 0.8},\n",
-    "            'intrusion': {'failed_logins': (5, 50), 'privilege_escalation': 0.7}\n",
-    "        }\n",
-    "        \n",
-    "    def generate_network_traffic_data(self, n_samples=10000):\n",
-    "        \"\"\"Generate realistic network traffic data with threat indicators.\"\"\"\n",
-    "        \n",
-    "        data = []\n",
-    "        \n",
-    "        for i in range(n_samples):\n",
-    "            # Determine if this is an attack (20% attack rate)\n",
-    "            is_attack = np.random.random() < 0.2\n",
-    "            \n",
-    "            if is_attack:\n",
-    "                attack_type = np.random.choice(['ddos', 'malware', 'phishing', 'intrusion'])\n",
-    "                sample = self._generate_attack_sample(attack_type)\n",
-    "                sample['label'] = 1\n",
-    "                sample['attack_type'] = attack_type\n",
-    "            else:\n",
-    "                sample = self._generate_normal_sample()\n",
-    "                sample['label'] = 0\n",
-    "                sample['attack_type'] = 'normal'\n",
-    "            \n",
-    "            sample['timestamp'] = datetime.now().timestamp() + i\n",
-    "            data.append(sample)\n",
-    "        \n",
-    "        return pd.DataFrame(data)\n",
-    "    \n",
-    "    def _generate_attack_sample(self, attack_type):\n",
-    "        \"\"\"Generate attack-specific network traffic features.\"\"\"\n",
-    "        \n",
-    "        base_features = self._generate_base_features()\n",
-    "        \n",
-    "        if attack_type == 'ddos':\n",
-    "            base_features.update({\n",
-    "                'packet_rate': np.random.uniform(1000, 10000),\n",
-    "                'connection_duration': np.random.uniform(0.1, 2),\n",
-    "                'payload_size': np.random.uniform(1, 100),\n",
-    "                'source_ip_diversity': np.random.uniform(0.1, 0.3)\n",
-    "            })\n",
-    "        \n",
-    "        elif attack_type == 'malware':\n",
-    "            base_features.update({\n",
-    "                'file_entropy': np.random.uniform(7.5, 8.0),\n",
-    "                'suspicious_imports': np.random.randint(5, 20),\n",
-    "                'code_obfuscation': np.random.uniform(0.7, 1.0),\n",
-    "                'network_callbacks': np.random.randint(1, 10)\n",
-    "            })\n",
-    "        \n",
-    "        elif attack_type == 'phishing':\n",
-    "            base_features.update({\n",
-    "                'domain_age': np.random.uniform(0, 30),\n",
-    "                'ssl_suspicious': np.random.uniform(0.8, 1.0),\n",
-    "                'url_length': np.random.uniform(100, 500),\n",
-    "                'subdomain_count': np.random.randint(3, 10)\n",
-    "            })\n",
-    "        \n",
-    "        elif attack_type == 'intrusion':\n",
-    "            base_features.update({\n",
-    "                'failed_logins': np.random.randint(5, 50),\n",
-    "                'privilege_escalation': np.random.uniform(0.7, 1.0),\n",
-    "                'lateral_movement': np.random.uniform(0.5, 1.0),\n",
-    "                'unusual_process': np.random.uniform(0.6, 1.0)\n",
-    "            })\n",
-    "        \n",
-    "        return base_features\n",
-    "    \n",
-    "    def _generate_normal_sample(self):\n",
-    "        \"\"\"Generate normal network traffic features.\"\"\"\n",
-    "        \n",
-    "        features = self._generate_base_features()\n",
-    "        features.update({\n",
-    "            'packet_rate': np.random.uniform(10, 500),\n",
-    "            'connection_duration': np.random.uniform(5, 300),\n",
-    "            'payload_size': np.random.uniform(500, 5000),\n",
-    "            'source_ip_diversity': np.random.uniform(0.8, 1.0),\n",
-    "            'file_entropy': np.random.uniform(1.0, 6.0),\n",
-    "            'suspicious_imports': np.random.randint(0, 3),\n",
-    "            'code_obfuscation': np.random.uniform(0.0, 0.3),\n",
-    "            'network_callbacks': np.random.randint(0, 2),\n",
-    "            'domain_age': np.random.uniform(365, 3650),\n",
-    "            'ssl_suspicious': np.random.uniform(0.0, 0.2),\n",
-    "            'url_length': np.random.uniform(20, 80),\n",
-    "            'subdomain_count': np.random.randint(0, 2),\n",
-    "            'failed_logins': np.random.randint(0, 3),\n",
-    "            'privilege_escalation': np.random.uniform(0.0, 0.2),\n",
-    "            'lateral_movement': np.random.uniform(0.0, 0.1),\n",
-    "            'unusual_process': np.random.uniform(0.0, 0.2)\n",
-    "        })\n",
-    "        \n",
-    "        return features\n",
-    "    \n",
-    "    def _generate_base_features(self):\n",
-    "        \"\"\"Generate base network features common to all samples.\"\"\"\n",
-    "        \n",
-    "        return {\n",
-    "            'bytes_sent': np.random.randint(100, 100000),\n",
-    "            'bytes_received': np.random.randint(100, 100000),\n",
-    "            'packets_sent': np.random.randint(10, 1000),\n",
-    "            'packets_received': np.random.randint(10, 1000),\n",
-    "            'connection_count': np.random.randint(1, 100),\n",
-    "            'port_diversity': np.random.uniform(0.1, 1.0),\n",
-    "            'protocol_diversity': np.random.uniform(0.1, 1.0),\n",
-    "            'time_variance': np.random.uniform(0.1, 1.0)\n",
-    "        }\n",
-    "\n",
-    "# Generate enhanced dataset\n",
-    "print(\"🔄 Generating enhanced cybersecurity dataset...\")\n",
-    "data_generator = CybersecurityDataGenerator()\n",
-    "df = data_generator.generate_network_traffic_data(n_samples=15000)\n",
-    "\n",
-    "print(f\"✅ Generated dataset with {len(df)} samples\")\n",
-    "print(f\"Attack distribution:\")\n",
-    "print(df['attack_type'].value_counts())\n",
-    "print(f\"\\nDataset shape: {df.shape}\")\n",
-    "print(f\"Features: {list(df.columns)}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 3. Advanced Feature Engineering and Analysis"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class AdvancedFeatureEngineer:\n",
-    "    \"\"\"Advanced feature engineering for cybersecurity data.\"\"\"\n",
-    "    \n",
-    "    def __init__(self):\n",
-    "        self.scaler = StandardScaler()\n",
-    "        self.feature_selector = SelectKBest(f_classif, k=20)\n",
-    "        self.pca = PCA(n_components=0.95)\n",
-    "        \n",
-    "    def create_advanced_features(self, df):\n",
-    "        \"\"\"Create advanced engineered features.\"\"\"\n",
-    "        \n",
-    "        df_eng = df.copy()\n",
-    "        \n",
-    "        # Traffic patterns\n",
-    "        df_eng['bytes_ratio'] = df_eng['bytes_sent'] / (df_eng['bytes_received'] + 1)\n",
-    "        df_eng['packets_ratio'] = df_eng['packets_sent'] / (df_eng['packets_received'] + 1)\n",
-    "        df_eng['avg_packet_size'] = (df_eng['bytes_sent'] + df_eng['bytes_received']) / (df_eng['packets_sent'] + df_eng['packets_received'] + 1)\n",
-    "        \n",
-    "        # Anomaly indicators\n",
-    "        df_eng['traffic_volume'] = df_eng['bytes_sent'] + df_eng['bytes_received']\n",
-    "        df_eng['connection_efficiency'] = df_eng['traffic_volume'] / (df_eng['connection_count'] + 1)\n",
-    "        df_eng['port_concentration'] = 1 - df_eng['port_diversity']\n",
-    "        \n",
-    "        # Security-specific features\n",
-    "        df_eng['entropy_threshold'] = (df_eng.get('file_entropy', 0) > 7.0).astype(int)\n",
-    "        df_eng['high_import_count'] = (df_eng.get('suspicious_imports', 0) > 5).astype(int)\n",
-    "        df_eng['short_domain_age'] = (df_eng.get('domain_age', 365) < 90).astype(int)\n",
-    "        df_eng['high_failed_logins'] = (df_eng.get('failed_logins', 0) > 5).astype(int)\n",
-    "        \n",
-    "        # Composite risk scores\n",
-    "        df_eng['malware_risk'] = (\n",
-    "            df_eng.get('file_entropy', 0) * 0.3 +\n",
-    "            df_eng.get('suspicious_imports', 0) * 0.1 +\n",
-    "            df_eng.get('code_obfuscation', 0) * 0.4 +\n",
-    "            df_eng.get('network_callbacks', 0) * 0.2\n",
-    "        )\n",
-    "        \n",
-    "        df_eng['network_anomaly_score'] = (\n",
-    "            (df_eng['packet_rate'] / 1000) * 0.4 +\n",
-    "            (1 / (df_eng['connection_duration'] + 1)) * 0.3 +\n",
-    "            df_eng['port_concentration'] * 0.3\n",
-    "        )\n",
-    "        \n",
-    "        df_eng['phishing_risk'] = (\n",
-    "            (1 / (df_eng.get('domain_age', 365) + 1)) * 0.3 +\n",
-    "            df_eng.get('ssl_suspicious', 0) * 0.4 +\n",
-    "            (df_eng.get('url_length', 50) / 100) * 0.2 +\n",
-    "            (df_eng.get('subdomain_count', 0) / 10) * 0.1\n",
-    "        )\n",
-    "        \n",
-    "        return df_eng\n",
-    "    \n",
-    "    def select_features(self, df, target_col='label'):\n",
-    "        \"\"\"Select most important features.\"\"\"\n",
-    "        \n",
-    "        # Exclude non-numeric and target columns\n",
-    "        exclude_cols = [target_col, 'attack_type', 'timestamp']\n",
-    "        feature_cols = [col for col in df.columns if col not in exclude_cols]\n",
-    "        \n",
-    "        X = df[feature_cols]\n",
-    "        y = df[target_col]\n",
-    "        \n",
-    "        # Handle missing values\n",
-    "        X = X.fillna(0)\n",
-    "        \n",
-    "        # Feature selection\n",
-    "        X_selected = self.feature_selector.fit_transform(X, y)\n",
-    "        selected_features = [feature_cols[i] for i in self.feature_selector.get_support(indices=True)]\n",
-    "        \n",
-    "        return X_selected, selected_features\n",
-    "\n",
-    "# Apply advanced feature engineering\n",
-    "print(\"🔄 Applying advanced feature engineering...\")\n",
-    "feature_engineer = AdvancedFeatureEngineer()\n",
-    "df_engineered = feature_engineer.create_advanced_features(df)\n",
-    "\n",
-    "print(f\"✅ Enhanced dataset with {df_engineered.shape[1]} features\")\n",
-    "print(f\"New features created: {set(df_engineered.columns) - set(df.columns)}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 4. Advanced Visualization and EDA"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create comprehensive visualizations\n",
-    "def create_threat_analysis_dashboard(df):\n",
-    "    \"\"\"Create an interactive dashboard for threat analysis.\"\"\"\n",
-    "    \n",
-    "    # Attack type distribution\n",
-    "    fig1 = px.pie(df, names='attack_type', title='Attack Type Distribution',\n",
-    "                  color_discrete_sequence=px.colors.qualitative.Set3)\n",
-    "    fig1.show()\n",
-    "    \n",
-    "    # Feature correlation heatmap\n",
-    "    numeric_cols = df.select_dtypes(include=[np.number]).columns\n",
-    "    corr_matrix = df[numeric_cols].corr()\n",
-    "    \n",
-    "    fig2 = px.imshow(corr_matrix, \n",
-    "                     title='Feature Correlation Matrix',\n",
-    "                     color_continuous_scale='RdBu',\n",
-    "                     aspect='auto')\n",
-    "    fig2.show()\n",
-    "    \n",
-    "    # Risk score distributions\n",
-    "    fig3 = make_subplots(rows=2, cols=2,\n",
-    "                        subplot_titles=['Malware Risk', 'Network Anomaly Score', \n",
-    "                                       'Phishing Risk', 'Traffic Volume'],\n",
-    "                        specs=[[{\"secondary_y\": False}, {\"secondary_y\": False}],\n",
-    "                               [{\"secondary_y\": False}, {\"secondary_y\": False}]])\n",
-    "    \n",
-    "    # Add histograms for each risk score\n",
-    "    for i, (col, color) in enumerate([\n",
-    "        ('malware_risk', 'red'),\n",
-    "        ('network_anomaly_score', 'blue'),\n",
-    "        ('phishing_risk', 'green'),\n",
-    "        ('traffic_volume', 'orange')\n",
-    "    ]):\n",
-    "        row = (i // 2) + 1\n",
-    "        col_num = (i % 2) + 1\n",
-    "        \n",
-    "        if col in df.columns:\n",
-    "            fig3.add_histogram(x=df[col], name=col, \n",
-    "                             row=row, col=col_num,\n",
-    "                             marker_color=color, opacity=0.7)\n",
-    "    \n",
-    "    fig3.update_layout(title_text=\"Risk Score Distributions\", showlegend=False)\n",
-    "    fig3.show()\n",
-    "    \n",
-    "    # Attack patterns over time\n",
-    "    df_time = df.copy()\n",
-    "    df_time['time_bin'] = pd.cut(df_time['timestamp'], bins=20)\n",
-    "    attack_timeline = df_time.groupby(['time_bin', 'attack_type']).size().reset_index(name='count')\n",
-    "    \n",
-    "    fig4 = px.bar(attack_timeline, x='time_bin', y='count', color='attack_type',\n",
-    "                  title='Attack Patterns Over Time',\n",
-    "                  color_discrete_sequence=px.colors.qualitative.Set2)\n",
-    "    fig4.update_xaxis(title='Time Bins')\n",
-    "    fig4.show()\n",
-    "\n",
-    "print(\"📊 Creating threat analysis dashboard...\")\n",
-    "create_threat_analysis_dashboard(df_engineered)\n",
-    "print(\"✅ Dashboard created successfully\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 5. Advanced ML Model Development"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class AdvancedThreatDetector:\n",
-    "    \"\"\"Advanced threat detection with multiple ML models.\"\"\"\n",
-    "    \n",
-    "    def __init__(self):\n",
-    "        self.models = {}\n",
-    "        self.scalers = {}\n",
-    "        self.feature_names = []\n",
-    "        self.results = {}\n",
-    "        \n",
-    "    def prepare_data(self, df, target_col='label', test_size=0.3):\n",
-    "        \"\"\"Prepare data for training.\"\"\"\n",
-    "        \n",
-    "        # Feature selection\n",
-    "        feature_engineer = AdvancedFeatureEngineer()\n",
-    "        X, self.feature_names = feature_engineer.select_features(df, target_col)\n",
-    "        y = df[target_col].values\n",
-    "        \n",
-    "        # Train-test split\n",
-    "        X_train, X_test, y_train, y_test = train_test_split(\n",
-    "            X, y, test_size=test_size, random_state=42, stratify=y\n",
-    "        )\n",
-    "        \n",
-    "        # Scale features\n",
-    "        scaler = StandardScaler()\n",
-    "        X_train_scaled = scaler.fit_transform(X_train)\n",
-    "        X_test_scaled = scaler.transform(X_test)\n",
-    "        \n",
-    "        self.scalers['standard'] = scaler\n",
-    "        \n",
-    "        return X_train_scaled, X_test_scaled, y_train, y_test\n",
-    "    \n",
-    "    def train_ensemble_models(self, X_train, X_test, y_train, y_test):\n",
-    "        \"\"\"Train multiple models for ensemble.\"\"\"\n",
-    "        \n",
-    "        # Define models\n",
-    "        models_config = {\n",
-    "            'random_forest': RandomForestClassifier(n_estimators=200, max_depth=15, random_state=42),\n",
-    "            'xgboost': xgb.XGBClassifier(n_estimators=200, max_depth=10, learning_rate=0.1, random_state=42),\n",
-    "            'gradient_boost': GradientBoostingClassifier(n_estimators=150, max_depth=8, random_state=42),\n",
-    "            'svm': SVC(kernel='rbf', probability=True, random_state=42),\n",
-    "            'logistic': LogisticRegression(random_state=42, max_iter=1000)\n",
-    "        }\n",
-    "        \n",
-    "        # Train and evaluate each model\n",
-    "        for name, model in models_config.items():\n",
-    "            print(f\"🔄 Training {name}...\")\n",
-    "            \n",
-    "            start_time = time.time()\n",
-    "            model.fit(X_train, y_train)\n",
-    "            training_time = time.time() - start_time\n",
-    "            \n",
-    "            # Predictions\n",
-    "            y_pred = model.predict(X_test)\n",
-    "            y_pred_proba = model.predict_proba(X_test)[:, 1]\n",
-    "            \n",
-    "            # Metrics\n",
-    "            auc_score = roc_auc_score(y_test, y_pred_proba)\n",
-    "            cv_scores = cross_val_score(model, X_train, y_train, cv=5)\n",
-    "            \n",
-    "            self.models[name] = model\n",
-    "            self.results[name] = {\n",
-    "                'auc_score': auc_score,\n",
-    "                'cv_mean': cv_scores.mean(),\n",
-    "                'cv_std': cv_scores.std(),\n",
-    "                'training_time': training_time,\n",
-    "                'predictions': y_pred,\n",
-    "                'probabilities': y_pred_proba\n",
-    "            }\n",
-    "            \n",
-    "            print(f\"✅ {name}: AUC={auc_score:.4f}, CV={cv_scores.mean():.4f}±{cv_scores.std():.4f}\")\n",
-    "    \n",
-    "    def train_deep_learning_model(self, X_train, X_test, y_train, y_test):\n",
-    "        \"\"\"Train deep learning model for threat detection.\"\"\"\n",
-    "        \n",
-    "        print(\"🔄 Training deep learning model...\")\n",
-    "        \n",
-    "        # Build neural network\n",
-    "        model = Sequential([\n",
-    "            Dense(256, activation='relu', input_shape=(X_train.shape[1],)),\n",
-    "            Dropout(0.3),\n",
-    "            Dense(128, activation='relu'),\n",
-    "            Dropout(0.3),\n",
-    "            Dense(64, activation='relu'),\n",
-    "            Dropout(0.2),\n",
-    "            Dense(32, activation='relu'),\n",
-    "            Dense(1, activation='sigmoid')\n",
-    "        ])\n",
-    "        \n",
-    "        model.compile(\n",
-    "            optimizer=Adam(learning_rate=0.001),\n",
-    "            loss='binary_crossentropy',\n",
-    "            metrics=['accuracy', 'precision', 'recall']\n",
-    "        )\n",
-    "        \n",
-    "        # Callbacks\n",
-    "        callbacks = [\n",
-    "            EarlyStopping(patience=10, restore_best_weights=True),\n",
-    "            ReduceLROnPlateau(factor=0.5, patience=5)\n",
-    "        ]\n",
-    "        \n",
-    "        # Train\n",
-    "        history = model.fit(\n",
-    "            X_train, y_train,\n",
-    "            validation_data=(X_test, y_test),\n",
-    "            epochs=100,\n",
-    "            batch_size=32,\n",
-    "            callbacks=callbacks,\n",
-    "            verbose=0\n",
-    "        )\n",
-    "        \n",
-    "        # Evaluate\n",
-    "        y_pred_proba = model.predict(X_test).flatten()\n",
-    "        y_pred = (y_pred_proba > 0.5).astype(int)\n",
-    "        auc_score = roc_auc_score(y_test, y_pred_proba)\n",
-    "        \n",
-    "        self.models['deep_learning'] = model\n",
-    "        self.results['deep_learning'] = {\n",
-    "            'auc_score': auc_score,\n",
-    "            'history': history,\n",
-    "            'predictions': y_pred,\n",
-    "            'probabilities': y_pred_proba\n",
-    "        }\n",
-    "        \n",
-    "        print(f\"✅ Deep Learning: AUC={auc_score:.4f}\")\n",
-    "        return model, history\n",
-    "    \n",
-    "    def create_ensemble_prediction(self, X_test):\n",
-    "        \"\"\"Create ensemble prediction from all models.\"\"\"\n",
-    "        \n",
-    "        predictions = []\n",
-    "        weights = []\n",
-    "        \n",
-    "        for name, model in self.models.items():\n",
-    "            if name == 'deep_learning':\n",
-    "                pred_proba = model.predict(X_test).flatten()\n",
-    "            else:\n",
-    "                pred_proba = model.predict_proba(X_test)[:, 1]\n",
-    "            \n",
-    "            predictions.append(pred_proba)\n",
-    "            weights.append(self.results[name]['auc_score'])\n",
-    "        \n",
-    "        # Weighted ensemble\n",
-    "        weights = np.array(weights) / np.sum(weights)\n",
-    "        ensemble_pred = np.average(predictions, axis=0, weights=weights)\n",
-    "        \n",
-    "        return ensemble_pred\n",
-    "\n",
-    "# Initialize and train models\n",
-    "print(\"🚀 Starting advanced ML model training...\")\n",
-    "detector = AdvancedThreatDetector()\n",
-    "\n",
-    "# Prepare data\n",
-    "X_train, X_test, y_train, y_test = detector.prepare_data(df_engineered)\n",
-    "print(f\"Training set: {X_train.shape}, Test set: {X_test.shape}\")\n",
-    "\n",
-    "# Train ensemble models\n",
-    "detector.train_ensemble_models(X_train, X_test, y_train, y_test)\n",
-    "\n",
-    "# Train deep learning model\n",
-    "dl_model, dl_history = detector.train_deep_learning_model(X_train, X_test, y_train, y_test)\n",
-    "\n",
-    "# Create ensemble prediction\n",
-    "ensemble_pred = detector.create_ensemble_prediction(X_test)\n",
-    "ensemble_auc = roc_auc_score(y_test, ensemble_pred)\n",
-    "\n",
-    "print(f\"\\n🎯 Ensemble Model AUC: {ensemble_auc:.4f}\")\n",
-    "print(\"✅ All models trained successfully!\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 6. Model Evaluation and Interpretability"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Comprehensive model evaluation\n",
-    "def evaluate_models(detector, X_test, y_test):\n",
-    "    \"\"\"Comprehensive model evaluation and comparison.\"\"\"\n",
-    "    \n",
-    "    print(\"📊 Model Performance Summary:\")\n",
-    "    print(\"=\" * 60)\n",
-    "    \n",
-    "    # Performance comparison\n",
-    "    performance_data = []\n",
-    "    \n",
-    "    for name, results in detector.results.items():\n",
-    "        performance_data.append({\n",
-    "            'Model': name.replace('_', ' ').title(),\n",
-    "            'AUC Score': f\"{results['auc_score']:.4f}\",\n",
-    "            'CV Mean': f\"{results.get('cv_mean', 0):.4f}\",\n",
-    "            'CV Std': f\"{results.get('cv_std', 0):.4f}\",\n",
-    "            'Training Time': f\"{results.get('training_time', 0):.2f}s\"\n",
-    "        })\n",
-    "    \n",
-    "    performance_df = pd.DataFrame(performance_data)\n",
-    "    print(performance_df.to_string(index=False))\n",
-    "    \n",
-    "    # ROC Curves\n",
-    "    plt.figure(figsize=(12, 8))\n",
-    "    \n",
-    "    for name, results in detector.results.items():\n",
-    "        fpr, tpr, _ = roc_curve(y_test, results['probabilities'])\n",
-    "        plt.plot(fpr, tpr, label=f\"{name} (AUC = {results['auc_score']:.3f})\")\n",
-    "    \n",
-    "    # Ensemble ROC\n",
-    "    ensemble_pred = detector.create_ensemble_prediction(X_test)\n",
-    "    fpr_ens, tpr_ens, _ = roc_curve(y_test, ensemble_pred)\n",
-    "    ensemble_auc = roc_auc_score(y_test, ensemble_pred)\n",
-    "    plt.plot(fpr_ens, tpr_ens, label=f\"Ensemble (AUC = {ensemble_auc:.3f})\", \n",
-    "             linewidth=3, linestyle='--')\n",
-    "    \n",
-    "    plt.plot([0, 1], [0, 1], 'k--', alpha=0.5)\n",
-    "    plt.xlabel('False Positive Rate')\n",
-    "    plt.ylabel('True Positive Rate')\n",
-    "    plt.title('ROC Curves - Model Comparison')\n",
-    "    plt.legend()\n",
-    "    plt.grid(True, alpha=0.3)\n",
-    "    plt.show()\n",
-    "    \n",
-    "    # Feature importance (Random Forest)\n",
-    "    if 'random_forest' in detector.models:\n",
-    "        rf_model = detector.models['random_forest']\n",
-    "        feature_importance = pd.DataFrame({\n",
-    "            'feature': detector.feature_names,\n",
-    "            'importance': rf_model.feature_importances_\n",
-    "        }).sort_values('importance', ascending=False).head(15)\n",
-    "        \n",
-    "        plt.figure(figsize=(10, 8))\n",
-    "        plt.barh(feature_importance['feature'], feature_importance['importance'])\n",
-    "        plt.xlabel('Feature Importance')\n",
-    "        plt.title('Top 15 Most Important Features (Random Forest)')\n",
-    "        plt.gca().invert_yaxis()\n",
-    "        plt.tight_layout()\n",
-    "        plt.show()\n",
-    "    \n",
-    "    # Confusion matrices\n",
-    "    fig, axes = plt.subplots(2, 3, figsize=(15, 10))\n",
-    "    axes = axes.flatten()\n",
-    "    \n",
-    "    model_names = list(detector.results.keys())[:6]\n",
-    "    \n",
-    "    for i, name in enumerate(model_names):\n",
-    "        if i < len(axes):\n",
-    "            y_pred = detector.results[name]['predictions']\n",
-    "            cm = confusion_matrix(y_test, y_pred)\n",
-    "            \n",
-    "            sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=axes[i])\n",
-    "            axes[i].set_title(f'{name.replace(\"_\", \" \").title()}')\n",
-    "            axes[i].set_xlabel('Predicted')\n",
-    "            axes[i].set_ylabel('Actual')\n",
-    "    \n",
-    "    # Hide empty subplots\n",
-    "    for i in range(len(model_names), len(axes)):\n",
-    "        axes[i].set_visible(False)\n",
-    "    \n",
-    "    plt.tight_layout()\n",
-    "    plt.show()\n",
-    "\n",
-    "# Run evaluation\n",
-    "evaluate_models(detector, X_test, y_test)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 7. Real-time Threat Scoring System"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class RealTimeThreatScorer:\n",
-    "    \"\"\"Real-time threat scoring system for production deployment.\"\"\"\n",
-    "    \n",
-    "    def __init__(self, detector, feature_engineer):\n",
-    "        self.detector = detector\n",
-    "        self.feature_engineer = feature_engineer\n",
-    "        self.threat_threshold = 0.7\n",
-    "        self.alert_history = []\n",
-    "        \n",
-    "    def score_threat(self, network_data):\n",
-    "        \"\"\"Score a single network traffic sample.\"\"\"\n",
-    "        \n",
-    "        try:\n",
-    "            # Convert to DataFrame if dict\n",
-    "            if isinstance(network_data, dict):\n",
-    "                df_sample = pd.DataFrame([network_data])\n",
-    "            else:\n",
-    "                df_sample = network_data.copy()\n",
-    "            \n",
-    "            # Apply feature engineering\n",
-    "            df_engineered = self.feature_engineer.create_advanced_features(df_sample)\n",
-    "            \n",
-    "            # Extract features\n",
-    "            feature_cols = self.detector.feature_names\n",
-    "            X = df_engineered[feature_cols].fillna(0).values\n",
-    "            \n",
-    "            # Scale features\n",
-    "            X_scaled = self.detector.scalers['standard'].transform(X)\n",
-    "            \n",
-    "            # Get ensemble prediction\n",
-    "            threat_score = self.detector.create_ensemble_prediction(X_scaled)[0]\n",
-    "            \n",
-    "            # Determine threat level\n",
-    "            if threat_score >= 0.9:\n",
-    "                threat_level = 'CRITICAL'\n",
-    "            elif threat_score >= 0.7:\n",
-    "                threat_level = 'HIGH'\n",
-    "            elif threat_score >= 0.4:\n",
-    "                threat_level = 'MEDIUM'\n",
-    "            elif threat_score >= 0.2:\n",
-    "                threat_level = 'LOW'\n",
-    "            else:\n",
-    "                threat_level = 'BENIGN'\n",
-    "            \n",
-    "            # Create detailed analysis\n",
-    "            analysis = self._create_threat_analysis(df_engineered.iloc[0], threat_score)\n",
-    "            \n",
-    "            result = {\n",
-    "                'threat_score': float(threat_score),\n",
-    "                'threat_level': threat_level,\n",
-    "                'is_threat': threat_score >= self.threat_threshold,\n",
-    "                'timestamp': datetime.now().isoformat(),\n",
-    "                'analysis': analysis\n",
-    "            }\n",
-    "            \n",
-    "            # Log high-risk threats\n",
-    "            if threat_score >= self.threat_threshold:\n",
-    "                self.alert_history.append(result)\n",
-    "                print(f\"🚨 THREAT DETECTED: {threat_level} (Score: {threat_score:.3f})\")\n",
-    "            \n",
-    "            return result\n",
-    "            \n",
-    "        except Exception as e:\n",
-    "            return {\n",
-    "                'error': str(e),\n",
-    "                'threat_score': 0.0,\n",
-    "                'threat_level': 'ERROR',\n",
-    "                'is_threat': False,\n",
-    "                'timestamp': datetime.now().isoformat()\n",
-    "            }\n",
-    "    \n",
-    "    def _create_threat_analysis(self, sample, threat_score):\n",
-    "        \"\"\"Create detailed threat analysis.\"\"\"\n",
-    "        \n",
-    "        analysis = {\n",
-    "            'risk_factors': [],\n",
-    "            'recommendations': [],\n",
-    "            'confidence': 'High' if threat_score > 0.8 else 'Medium' if threat_score > 0.5 else 'Low'\n",
-    "        }\n",
-    "        \n",
-    "        # Check specific risk indicators\n",
-    "        if sample.get('malware_risk', 0) > 0.5:\n",
-    "            analysis['risk_factors'].append('High malware risk detected')\n",
-    "            analysis['recommendations'].append('Perform deep malware scan')\n",
-    "        \n",
-    "        if sample.get('network_anomaly_score', 0) > 0.5:\n",
-    "            analysis['risk_factors'].append('Abnormal network traffic patterns')\n",
-    "            analysis['recommendations'].append('Monitor network connections')\n",
-    "        \n",
-    "        if sample.get('phishing_risk', 0) > 0.5:\n",
-    "            analysis['risk_factors'].append('Suspicious domain characteristics')\n",
-    "            analysis['recommendations'].append('Verify domain legitimacy')\n",
-    "        \n",
-    "        if sample.get('high_failed_logins', 0) == 1:\n",
-    "            analysis['risk_factors'].append('Multiple failed login attempts')\n",
-    "            analysis['recommendations'].append('Check for brute force attacks')\n",
-    "        \n",
-    "        if not analysis['risk_factors']:\n",
-    "            analysis['risk_factors'].append('General anomaly detected')\n",
-    "            analysis['recommendations'].append('Continue monitoring')\n",
-    "        \n",
-    "        return analysis\n",
-    "    \n",
-    "    def get_threat_statistics(self):\n",
-    "        \"\"\"Get threat detection statistics.\"\"\"\n",
-    "        \n",
-    "        if not self.alert_history:\n",
-    "            return {'total_threats': 0, 'threat_levels': {}, 'recent_threats': []}\n",
-    "        \n",
-    "        threat_levels = Counter([alert['threat_level'] for alert in self.alert_history])\n",
-    "        recent_threats = self.alert_history[-10:]  # Last 10 threats\n",
-    "        \n",
-    "        return {\n",
-    "            'total_threats': len(self.alert_history),\n",
-    "            'threat_levels': dict(threat_levels),\n",
-    "            'recent_threats': recent_threats\n",
-    "        }\n",
-    "\n",
-    "# Initialize real-time threat scorer\n",
-    "threat_scorer = RealTimeThreatScorer(detector, feature_engineer)\n",
-    "\n",
-    "# Test with some sample data\n",
-    "print(\"🔍 Testing real-time threat scoring...\")\n",
-    "\n",
-    "# Test with a few samples from our dataset\n",
-    "test_samples = df_engineered.sample(5).to_dict('records')\n",
-    "\n",
-    "for i, sample in enumerate(test_samples):\n",
-    "    result = threat_scorer.score_threat(sample)\n",
-    "    print(f\"\\nSample {i+1}: {result['threat_level']} (Score: {result['threat_score']:.3f})\")\n",
-    "    if result['analysis']['risk_factors']:\n",
-    "        print(f\"  Risk Factors: {', '.join(result['analysis']['risk_factors'])}\")\n",
-    "\n",
-    "# Get statistics\n",
-    "stats = threat_scorer.get_threat_statistics()\n",
-    "print(f\"\\n📈 Threat Statistics: {stats}\")\n",
-    "\n",
-    "print(\"\\n✅ Real-time threat scoring system ready!\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 8. Model Deployment and Saving"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Save all models and components for production use\n",
-    "import os\n",
-    "\n",
-    "# Create models directory\n",
-    "models_dir = '../models'\n",
-    "os.makedirs(models_dir, exist_ok=True)\n",
-    "\n",
-    "print(\"💾 Saving models for production deployment...\")\n",
-    "\n",
-    "# Save traditional ML models\n",
-    "for name, model in detector.models.items():\n",
-    "    if name != 'deep_learning':\n",
-    "        model_path = os.path.join(models_dir, f'{name}_model.joblib')\n",
-    "        joblib.dump(model, model_path)\n",
-    "        print(f\"✅ Saved {name} model to {model_path}\")\n",
-    "\n",
-    "# Save deep learning model\n",
-    "if 'deep_learning' in detector.models:\n",
-    "    dl_model_path = os.path.join(models_dir, 'deep_learning_model.h5')\n",
-    "    detector.models['deep_learning'].save(dl_model_path)\n",
-    "    print(f\"✅ Saved deep learning model to {dl_model_path}\")\n",
-    "\n",
-    "# Save scalers\n",
-    "scaler_path = os.path.join(models_dir, 'feature_scaler.joblib')\n",
-    "joblib.dump(detector.scalers['standard'], scaler_path)\n",
-    "print(f\"✅ Saved feature scaler to {scaler_path}\")\n",
-    "\n",
-    "# Save feature names\n",
-    "features_path = os.path.join(models_dir, 'feature_names.json')\n",
-    "with open(features_path, 'w') as f:\n",
-    "    json.dump(detector.feature_names, f)\n",
-    "print(f\"✅ Saved feature names to {features_path}\")\n",
-    "\n",
-    "# Save model metadata\n",
-    "metadata = {\n",
-    "    'model_version': '2.0',\n",
-    "    'training_date': datetime.now().isoformat(),\n",
-    "    'model_performance': {name: {'auc': results['auc_score']} \n",
-    "                         for name, results in detector.results.items()},\n",
-    "    'feature_count': len(detector.feature_names),\n",
-    "    'training_samples': len(df_engineered),\n",
-    "    'ensemble_auc': ensemble_auc\n",
-    "}\n",
-    "\n",
-    "metadata_path = os.path.join(models_dir, 'model_metadata.json')\n",
-    "with open(metadata_path, 'w') as f:\n",
-    "    json.dump(metadata, f, indent=2)\n",
-    "print(f\"✅ Saved model metadata to {metadata_path}\")\n",
-    "\n",
-    "# Create deployment script\n",
-    "deployment_script = '''\n",
-    "#!/usr/bin/env python3\n",
-    "\"\"\"\n",
-    "Cyber Forge AI - Production Model Deployment\n",
-    "Load and use the trained models for real-time threat detection\n",
-    "\"\"\"\n",
-    "\n",
-    "import joblib\n",
-    "import json\n",
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "from tensorflow.keras.models import load_model\n",
-    "\n",
-    "class ProductionThreatDetector:\n",
-    "    def __init__(self, models_dir='../models'):\n",
-    "        self.models_dir = models_dir\n",
-    "        self.models = {}\n",
-    "        self.scaler = None\n",
-    "        self.feature_names = []\n",
-    "        self.load_models()\n",
-    "    \n",
-    "    def load_models(self):\n",
-    "        \"\"\"Load all trained models.\"\"\"\n",
-    "        \n",
-    "        # Load traditional ML models\n",
-    "        model_files = {\n",
-    "            'random_forest': 'random_forest_model.joblib',\n",
-    "            'xgboost': 'xgboost_model.joblib',\n",
-    "            'gradient_boost': 'gradient_boost_model.joblib',\n",
-    "            'svm': 'svm_model.joblib',\n",
-    "            'logistic': 'logistic_model.joblib'\n",
-    "        }\n",
-    "        \n",
-    "        for name, filename in model_files.items():\n",
-    "            try:\n",
-    "                model_path = f\"{self.models_dir}/{filename}\"\n",
-    "                self.models[name] = joblib.load(model_path)\n",
-    "                print(f\"✅ Loaded {name} model\")\n",
-    "            except Exception as e:\n",
-    "                print(f\"❌ Failed to load {name}: {e}\")\n",
-    "        \n",
-    "        # Load deep learning model\n",
-    "        try:\n",
-    "            dl_path = f\"{self.models_dir}/deep_learning_model.h5\"\n",
-    "            self.models['deep_learning'] = load_model(dl_path)\n",
-    "            print(\"✅ Loaded deep learning model\")\n",
-    "        except Exception as e:\n",
-    "            print(f\"❌ Failed to load deep learning model: {e}\")\n",
-    "        \n",
-    "        # Load scaler and feature names\n",
-    "        self.scaler = joblib.load(f\"{self.models_dir}/feature_scaler.joblib\")\n",
-    "        \n",
-    "        with open(f\"{self.models_dir}/feature_names.json\", 'r') as f:\n",
-    "            self.feature_names = json.load(f)\n",
-    "        \n",
-    "        print(f\"✅ Loaded {len(self.models)} models successfully\")\n",
-    "    \n",
-    "    def predict_threat(self, network_data):\n",
-    "        \"\"\"Predict threat probability for network data.\"\"\"\n",
-    "        \n",
-    "        # This would include the same feature engineering and prediction logic\n",
-    "        # as implemented in the notebook\n",
-    "        pass\n",
-    "\n",
-    "if __name__ == \"__main__\":\n",
-    "    detector = ProductionThreatDetector()\n",
-    "    print(\"🚀 Production threat detector ready!\")\n",
-    "'''\n",
-    "\n",
-    "deployment_path = os.path.join(models_dir, 'deploy_models.py')\n",
-    "with open(deployment_path, 'w') as f:\n",
-    "    f.write(deployment_script)\n",
-    "print(f\"✅ Created deployment script at {deployment_path}\")\n",
-    "\n",
-    "print(\"\\n🎉 All models and components saved successfully!\")\n",
-    "print(f\"📁 Models directory: {os.path.abspath(models_dir)}\")\n",
-    "print(\"\\n📋 Saved components:\")\n",
-    "for file in os.listdir(models_dir):\n",
-    "    print(f\"  - {file}\")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## 9. Summary and Next Steps\n",
-    "\n",
-    "### 🎯 **Training Summary**\n",
-    "\n",
-    "This enhanced cybersecurity ML training notebook has successfully:\n",
-    "\n",
-    "1. **Generated Advanced Dataset** - Created realistic cybersecurity data with multiple attack types\n",
-    "2. **Feature Engineering** - Implemented sophisticated feature extraction and engineering\n",
-    "3. **Model Training** - Trained multiple ML models including deep learning\n",
-    "4. **Ensemble Methods** - Created weighted ensemble for improved accuracy\n",
-    "5. **Real-time Scoring** - Built production-ready threat scoring system\n",
-    "6. **Model Deployment** - Saved all components for production use\n",
-    "\n",
-    "### 📊 **Key Achievements**\n",
-    "\n",
-    "- **High Accuracy Models** - Multiple models with AUC > 0.85\n",
-    "- **Real-time Capabilities** - Sub-second threat detection\n",
-    "- **Comprehensive Analysis** - Detailed threat risk factor identification\n",
-    "- **Production Ready** - Complete deployment package\n",
-    "\n",
-    "### 🚀 **Next Steps**\n",
-    "\n",
-    "1. **Integration** - Integrate models with the main Cyber Forge AI application\n",
-    "2. **Monitoring** - Set up model performance monitoring in production\n",
-    "3. **Feedback Loop** - Implement continuous learning from new threat data\n",
-    "4. **Scaling** - Deploy models using containerization (Docker/Kubernetes)\n",
-    "5. **Updates** - Regular retraining with latest threat intelligence\n",
-    "\n",
-    "### 🛡️ **Security Considerations**\n",
-    "\n",
-    "- Models are trained on simulated data for safety\n",
-    "- Real-world deployment requires actual threat data\n",
-    "- Regular model updates needed for evolving threats\n",
-    "- Implement proper access controls for model endpoints\n",
-    "\n",
-    "---\n",
-    "\n",
-    "**🎉 Training Complete! Your advanced cybersecurity ML models are ready for deployment.**"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.9.0"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}