data_loader_single.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Loader For Single File\n",
    "\n",
    "This is the rebuild of data process functions. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import dgl\n",
    "import torch\n",
    "import collections\n",
    "import numpy as np\n",
    "import networkx as nx\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tool Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Label Function\n",
    "\n",
    "Converge TCP attack type to int. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def label(flag: str) -> int:\n",
    "    return {\n",
    "        '-': 0,\n",
    "        'snmpgetattack': 1,\n",
    "        'warez': 2,\n",
    "        'portsweep': 3,\n",
    "        'nmap': 4,\n",
    "        'warezclient': 5,\n",
    "        'ipsweep': 6,\n",
    "        'dict': 7,\n",
    "        'neptune': 8,\n",
    "        'smurf': 9,\n",
    "        'pod': 10,\n",
    "        'snmpguess': 11,\n",
    "        'teardrop': 12,\n",
    "        'satan': 13,\n",
    "        'httptunnel-e': 14,\n",
    "        'ignore': 15,\n",
    "        'mscan': 16,\n",
    "        'guest': 17,\n",
    "        'rootkit': 18,\n",
    "        'back': 19,\n",
    "        'apache2': 20,\n",
    "        'processtable': 21,\n",
    "        'mailbomb': 22,\n",
    "        'smurfttl': 23,\n",
    "        'saint': 24\n",
    "    }.get(flag[:-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Line Split Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def line_split(line: str) -> tuple:\n",
    "    src_ip, dst_ip, port, time, connect_type = line.split('\\t')\n",
    "    return int(src_ip), int(dst_ip), int(port), int(time), label(connect_type)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Data File Path\n",
    "\n",
    "train_set_path = 'data/train'\n",
    "valid_set_path = 'data/valid_query'\n",
    "test_set_path = 'data/test_query'\n",
    "\n",
    "# Features\n",
    "\n",
    "src_in_degree = collections.OrderedDict()\n",
    "src_out_degree = collections.OrderedDict()\n",
    "dst_in_degree = collections.OrderedDict()\n",
    "dst_out_degree = collections.OrderedDict()\n",
    "\n",
    "port_num = collections.OrderedDict()\n",
    "port_list = collections.OrderedDict()\n",
    "time_len = collections.OrderedDict()\n",
    "connect_num = collections.OrderedDict()\n",
    "label_list = collections.OrderedDict()\n",
    "\n",
    "# Tool Parameters\n",
    "\n",
    "nodes_origin = []\n",
    "edges_origin = {}\n",
    "\n",
    "edges_trans_src = []\n",
    "edges_trans_dst = []\n",
    "\n",
    "node_in_degree = {}\n",
    "node_out_degree = {}\n",
    "\n",
    "node_in_edges = {}\n",
    "node_out_edges = {}\n",
    "\n",
    "edge_src_list = {}\n",
    "edge_dst_list = {}\n",
    "\n",
    "# Count Parameters\n",
    "\n",
    "edge_index = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "path = 'data/train/train_000.txt'\n",
    "data = open(path)\n",
    "\n",
    "for line in data:\n",
    "    src_ip, dst_ip, port, time, connect_type = line_split(line)\n",
    "    \n",
    "    # Repeat Connections\n",
    "    if (src_ip, dst_ip) in edges_origin.keys():\n",
    "        edge_index_temp = edges_origin[(src_ip, dst_ip)]\n",
    "        \n",
    "        # Assign Features\n",
    "        time_len[edge_index_temp] += time\n",
    "        connect_num[edge_index_temp] += 1\n",
    "        label_list[edge_index_temp][connect_type] += 1\n",
    "        if port in port_list[edge_index_temp]:\n",
    "            pass\n",
    "        else:\n",
    "            port_num[edge_index_temp] += 1\n",
    "            port_list[edge_index_temp].append(port)\n",
    "    \n",
    "    # New Connections     \n",
    "    else:\n",
    "        # Record Origin Node and Edge\n",
    "        nodes_origin.append(src_ip)\n",
    "        nodes_origin.append(dst_ip)\n",
    "        edges_origin[(src_ip, dst_ip)] = edge_index\n",
    "        \n",
    "        # Update Node Parameters\n",
    "        if src_ip in node_out_degree.keys():\n",
    "            node_out_degree[src_ip] += 1\n",
    "        else:\n",
    "            node_out_degree[src_ip] = 1\n",
    "        if dst_ip in node_in_degree.keys():\n",
    "            node_in_degree[dst_ip] += 1\n",
    "        else:\n",
    "            node_in_degree[dst_ip] = 1\n",
    "\n",
    "        # Store Nodes' In-Out Edges\n",
    "        if src_ip in node_out_edges.keys():\n",
    "            node_out_edges[src_ip].append(edge_index)\n",
    "        else:\n",
    "            node_out_edges[src_ip] = [edge_index]\n",
    "        if dst_ip in node_in_edges.keys():\n",
    "            node_in_edges[dst_ip].append(edge_index)\n",
    "        else:\n",
    "            node_in_edges[dst_ip] = [edge_index]\n",
    "        \n",
    "        # Update Edge Parameters\n",
    "        if edge_index in edge_src_list.keys():\n",
    "            edge_src_list[edge_index].append(src_ip)\n",
    "        else:\n",
    "            edge_src_list[edge_index] = [src_ip]\n",
    "        if edge_index in edge_dst_list.keys():\n",
    "            edge_dst_list[edge_index].append(dst_ip)\n",
    "        else:\n",
    "            edge_dst_list[edge_index] = [dst_ip]\n",
    "            \n",
    "        # Assign Features\n",
    "        port_num[edge_index] = 1\n",
    "        port_list[edge_index] = [port]\n",
    "        time_len[edge_index] = time\n",
    "        connect_num[edge_index] = 1\n",
    "        label_list[edge_index] = [0 * x for x in range(25)]\n",
    "        label_list[edge_index][connect_type] += 1\n",
    "        \n",
    "        edge_index += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remove Repeats\n",
    "nodes_origin = list(set(nodes_origin))\n",
    "for i in range(len(edge_src_list)):\n",
    "    edge_src_list[i] = list(set(edge_src_list[i]))\n",
    "for i in range(len(edge_dst_list)):\n",
    "    edge_dst_list[i] = list(set(edge_dst_list[i]))\n",
    "    \n",
    "# Create Transform Graph\n",
    "for node in nodes_origin:\n",
    "    if not node in node_in_edges.keys() or not node in node_out_edges.keys():\n",
    "        continue\n",
    "    if not node_in_edges[node] or not node_out_edges[node]:\n",
    "        continue\n",
    "    for src_edge in node_in_edges[node]:\n",
    "        for dst_edge in node_out_edges[node]:\n",
    "            edges_trans_src.append(src_edge)\n",
    "            edges_trans_dst.append(dst_edge)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create Features\n",
    "for edge in edge_src_list.keys():\n",
    "    if edge_src_list[edge][0] not in node_in_degree.keys():\n",
    "        src_in_degree[edge] = 0\n",
    "    else:\n",
    "        src_in_degree[edge] = node_in_degree[edge_src_list[edge][0]]\n",
    "    if edge_src_list[edge][0] not in node_out_degree.keys():\n",
    "        src_out_degree[edge] = 0\n",
    "    else:\n",
    "        src_out_degree[edge] = node_out_degree[edge_src_list[edge][0]]\n",
    "    \n",
    "for edge in edge_dst_list.keys():\n",
    "    if edge_dst_list[edge][0] not in node_in_degree.keys():\n",
    "        dst_in_degree[edge] = 0\n",
    "    else:\n",
    "        dst_in_degree[edge] = node_in_degree[edge_dst_list[edge][0]]\n",
    "    if edge_dst_list[edge][0] not in node_out_degree.keys():\n",
    "        dst_out_degree[edge] = 0\n",
    "    else:\n",
    "        dst_out_degree[edge] = node_out_degree[edge_dst_list[edge][0]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Normalization Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "src_in_degree_norm = list(src_in_degree.values()) / np.linalg.norm(list(src_in_degree.values()))\n",
    "src_out_degree_norm = list(src_out_degree.values()) / np.linalg.norm(list(src_out_degree.values()))\n",
    "dst_in_degree_norm = list(dst_in_degree.values()) / np.linalg.norm(list(dst_in_degree.values()))\n",
    "dst_out_degree_norm = list(dst_out_degree.values()) / np.linalg.norm(list(dst_out_degree.values()))\n",
    "\n",
    "port_num_norm = list(port_num.values()) / np.linalg.norm(list(port_num.values()))\n",
    "time_len_norm = list(time_len.values()) / np.linalg.norm(list(time_len.values()))\n",
    "connect_num_norm = list(connect_num.values()) / np.linalg.norm(list(connect_num.values()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Feature Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_matrix = np.empty([1, 7])\n",
    "for i in range(len(edges_origin)):\n",
    "    feature_matrix = np.vstack((feature_matrix, [src_in_degree[i], src_out_degree[i], dst_in_degree[i], dst_out_degree[i], \\\n",
    "                                                 port_num[i], time_len[i], connect_num[i]]))\n",
    "feature_matrix = np.delete(feature_matrix, obj=0, axis=0)    \n",
    "feature_matrix = feature_matrix.astype(np.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Normalized Feature Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_matrix = np.empty([1, 7])\n",
    "for i in range(len(edges_origin)):\n",
    "    feature_matrix = np.vstack((feature_matrix, [src_in_degree_norm[i], src_out_degree_norm[i], dst_in_degree_norm[i], dst_out_degree_norm[i], \\\n",
    "                                                 port_num_norm[i], time_len_norm[i], connect_num_norm[i]]))\n",
    "feature_matrix = np.delete(feature_matrix, obj=0, axis=0)    \n",
    "feature_matrix = feature_matrix.astype(np.float32)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Status"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(len(src_in_degree))\n",
    "# print(edge_src_list)\n",
    "\n",
    "# print(edges_trans_src)\n",
    "# print(edges_trans_dst)\n",
    "\n",
    "# print(edges_origin)\n",
    "\n",
    "# print(len(nodes_origin))\n",
    "# print(len(edges_origin))\n",
    "\n",
    "# print(connect_num)\n",
    "\n",
    "# print(node_in_degree)\n",
    "\n",
    "# print(src_in_degree)\n",
    "\n",
    "# print(edges_trans_src)\n",
    "# print(edges_trans_dst)\n",
    "\n",
    "# print(label_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generate Graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use Unnormalized Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = dgl.DGLGraph()\n",
    "\n",
    "# Create Nodes and Edges\n",
    "\n",
    "g.add_nodes(len(edges_origin))\n",
    "g.add_edges(edges_trans_src, edges_trans_dst)\n",
    "\n",
    "# Assign Features\n",
    "\n",
    "g.ndata['src_in_degree'] = torch.tensor(list(src_in_degree.values()))\n",
    "g.ndata['src_out_degree'] = torch.tensor(list(src_out_degree.values()))\n",
    "g.ndata['dst_in_degree'] = torch.tensor(list(dst_in_degree.values()))\n",
    "g.ndata['dst_out_degree'] = torch.tensor(list(dst_out_degree.values()))\n",
    "g.ndata['port_num'] = torch.tensor(list(port_num.values()))\n",
    "g.ndata['time_len'] = torch.tensor(list(time_len.values()))\n",
    "g.ndata['connect_num'] = torch.tensor(list(connect_num.values()))\n",
    "\n",
    "g = dgl.add_self_loop(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Use Normalized Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = dgl.DGLGraph()\n",
    "\n",
    "# Create Nodes and Edges\n",
    "\n",
    "g.add_nodes(len(edges_origin))\n",
    "g.add_edges(edges_trans_src, edges_trans_dst)\n",
    "\n",
    "# Assign Features\n",
    "\n",
    "g.ndata['src_in_degree'] = torch.tensor(src_in_degree_norm)\n",
    "g.ndata['src_out_degree'] = torch.tensor(src_out_degree_norm)\n",
    "g.ndata['dst_in_degree'] = torch.tensor(dst_in_degree_norm)\n",
    "g.ndata['dst_out_degree'] = torch.tensor(dst_out_degree_norm)\n",
    "g.ndata['port_num'] = torch.tensor(port_num_norm)\n",
    "g.ndata['time_len'] = torch.tensor(time_len_norm)\n",
    "g.ndata['connect_num'] = torch.tensor(connect_num_norm)\n",
    "\n",
    "g = dgl.add_self_loop(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Graph Status"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nodes Number\t113\n",
      "Edges Number\t265\n"
     ]
    }
   ],
   "source": [
    "print('Nodes Number\\t{}\\nEdges Number\\t{}'.format(g.number_of_nodes(), g.number_of_edges()))\n",
    "# print(time_len_norm)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Show Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "options = {\"node_size\": 30}\n",
    "nx.draw(g.to_networkx(), with_labels=False, **options)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test on GCN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Packages\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from dgl.nn.pytorch import GraphConv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "class GCN(nn.Module):\n",
    "    def __init__(self, in_feats, hidden_size, num_classes):\n",
    "        super(GCN, self).__init__()\n",
    "        self.conv1 = GraphConv(in_feats, hidden_size)\n",
    "        self.conv2 = GraphConv(hidden_size, num_classes)\n",
    "\n",
    "    def forward(self, g, inputs):\n",
    "        h = self.conv1(g, inputs)\n",
    "        h = torch.relu(h)\n",
    "        h = self.conv2(g, h)\n",
    "        return h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0 | Loss: 17.3248\n",
      "Epoch 50 | Loss: 15.9657\n",
      "Epoch 100 | Loss: 14.4940\n",
      "Epoch 150 | Loss: 13.8079\n",
      "Epoch 200 | Loss: 12.8632\n",
      "Epoch 250 | Loss: 11.6041\n",
      "Epoch 300 | Loss: 10.2489\n",
      "Epoch 350 | Loss: 9.0489\n",
      "Epoch 400 | Loss: 8.1583\n",
      "Epoch 450 | Loss: 7.5772\n",
      "Epoch 500 | Loss: 7.2070\n",
      "Epoch 550 | Loss: 6.9558\n",
      "Epoch 600 | Loss: 6.7836\n",
      "Epoch 650 | Loss: 6.6663\n",
      "Epoch 700 | Loss: 6.5717\n",
      "Epoch 750 | Loss: 6.4943\n",
      "Epoch 800 | Loss: 6.4328\n",
      "Epoch 850 | Loss: 6.3809\n",
      "Epoch 900 | Loss: 6.3366\n",
      "Epoch 950 | Loss: 6.2861\n"
     ]
    }
   ],
   "source": [
    "net = GCN(7, 16, 25)\n",
    "\n",
    "inputs = torch.tensor(feature_matrix)\n",
    "labels = torch.tensor(list(label_list.values()), dtype=torch.float32)\n",
    "\n",
    "optimizer = torch.optim.Adam(net.parameters(), lr=0.01)\n",
    "loss_func = nn.MSELoss()\n",
    "\n",
    "# Recoder\n",
    "loss_list = []\n",
    "\n",
    "for epoch in range(1000):\n",
    "    outputs = net(g, inputs)\n",
    "    loss = loss_func(outputs, labels)\n",
    "    \n",
    "    optimizer.zero_grad()\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "    \n",
    "    loss_list.append(loss.item())\n",
    "    \n",
    "    if epoch % 50 == 0:\n",
    "        print('Epoch %d | Loss: %.4f' % (epoch, loss.item()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(loss_list)\n",
    "plt.show()"
   ]
  }
 ],
 "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}