An Empirical Study of the Deep Gradient Network Model to Perform Efficient Packet Classification

doi:10.21203/rs.3.rs-2878227/v1

Download PDF

Research Article

An Empirical Study of the Deep Gradient Network Model to Perform Efficient Packet Classification

https://doi.org/10.21203/rs.3.rs-2878227/v1

This work is licensed under a CC BY 4.0 License

Version 1

posted

You are reading this latest preprint version

The fast expansion of the Internet has increased the significance of packet classification in a network environment. The classification of the packets was done using various centred-on data structure techniques. However, the current algorithms have an issue with time budget and can't handle big rule sets. The main challenge is creating a packet classification algorithm that adds processing overhead and can handle enormous sets of classification rules. The proposed deep gradient network model (DGN) fixes these difficult problems. The anticipated model assists in handling complex tasks with higher prediction accuracy. The network adopts the dense network modelling concept to measure the feature representation and performs the classification process to fulfil prediction accuracy. The model works well compared to other approaches where the analysis is done with the standard benchmark ACL and evaluation is done with k-NN, SVM and DNN. Based on the outcomes, it is proven that the model establishes a better trade-off compared to other approaches.

packet classification

network

high speed

deep learning

classification

The basis of packet-switched networks is packet classification. For each incoming packet, network operations like switches utilize a set of rules to determine what to do with it. Routing, Quality of Service, or security policies are examples of higher-level domains from which the rules are derived [1]. They check the packets' metadata, including the transport protocol and destination IP address. When numerous rules are applicable, the highest priority rule is applied [2].

There are two types of software algorithms: hash-based and Based on a decision tree [3]. When compared, rules are indexed and matched using decision trees, whereas, in the latter, rule prefixes are hashed to conduct lookup through hash tables [4]. Other packet categorization techniques are less typical because they either use too much memory or are too sluggish. Ensuring the classifier can fit in the on-die cache of the CPU is essential for getting good classification performance in newer CPUs [5]. The lookup requires high-latency memory accesses when the classifier is too big, which causes the CPU to stall because the lookup's data-dependent access pattern prevents hardware prefetching [6]. Unfortunately, keeping the classifier in the cache gets more challenging as the number of rules increases [7]. The memory footprint and scalability are impacted, particularly with decision-tree approaches, since rules are frequently duplicated across numerous decision-tree leaves. As a result, in recent methods, Reduced rule repetition is the goal of techniques like Scalability-enhancing software like CutSplit [8], and NeuroCuts [9] are available. Large rule sets, which might number in the hundreds of thousands in modern data centres [10], are still too much for them to handle. Hash-based methods are less scalable due to the addition of rules because it increases the quantity and size of hash tables. These issues can be handled using deep learning approaches as they show a huge boom in various applications [11]. This work concentrates on modelling an efficient $DGN$ approach to perform packet classification. The performance is compared with various other approaches.

The work is structured as follows: section 2 provides an elaborate explanation for various prevailing approaches; section 3 discusses performance metrics, followed by the problem statement and methodology in sections 4 and 5. The outcomes are discussed in section 6, and the summary in section 7.

Identifying the rule out from a group an input packet satisfies is known as packet categorization. Several fields in the metadata of the packet are linked to a rule [12]. Since they can match, wildcards define ranges of more than one value. Ranges may overlap; thus, even if a packet matches many rules, only the highest priority one will be chosen [13]. Five overlapping matching rules and two fields are shown in a classifier. When an arriving packet matches both rules, R 3 is selected because it has a greater priority ($R3 and R4$). Scaling the performance of packet categorization is problematic as the number of matching fields and rules expands [14]. The complexity of software-defined data centre networks, in which each virtual network function has tens of thousands of matching variables and hundreds of thousands of rules, has drawn increased interest in this topic (up to 41 in OpenFlow 1.4).

The packets are seen as points, and the rules as hyper-cubes in a multidimensional space. The rule space's axes are non-negative numbers that denote various fields [15]. The rule space is partitioned recursively into sets of at most birth rules. The smallest subset for a given packet is thus determined using a tree traversal to match a rule, and the best match is then determined by looking at the rules in the subset using a secondary search [16]. Regrettably, when a rule covers many subspaces, performance in larger rule sets may be hampered by a rule replication issue because it significantly increases the memory footprint of the tree [7]. This problem is present in early works like HiCuts and HyperCuts. A distinct decision tree is generated for each collection of rules that share comparable qualities, according to more recent works like EffiCuts and CutSplit [18]. Reinforcement learning is utilized to efficiently explore a large tree configuration space in NeuroCuts, the most recent study in this field, to optimize decision tree parameters and minimize the number of memory visits made while traversing [19].

Using Tuple Space Search and the more current TupleMerge, the rule-set is separated into subsets based on the prefix bit count for each field. Because every rule in a subset member has the same number of prefix bits, they can all be used as hash table keys [20]. All its fields' prefix bits are extracted to classify an incoming packet, and all hash tables are searched for candidates that match the extracted prefix bits. False-positive results are removed by a secondary search, which also chooses the most important regulation. Decision trees function poorly in a rule update-prone online categorization issue. Nonetheless, hash-based algorithms do. However, decision trees have always been seen as quicker categorization methods. To close the gap and provide high-performance updates, the latest TupleMerge hash-based technique delivers great classification throughput [21].

All currently used strategies for packet classification do not scale well with the number of rules. It occurs due to their indexing structures spilling into slower L3 or DRAM from quick L1/L2 CPU caches [22]. 100K enables TupleMerge and NeuroCuts to reach the 1MB L2 cache rules each, whereas CutSplits does so with 500K rules, as demonstrated in our studies. Performance, however, depends on preserving the complete indexing structure in quick caches [23]. Hardware prefetchers are unsuccessful at reducing memory access latency due to the design; Access locality is lacking in hash and tree data structures, and accesses depend on the data. All lookups thus lose some of their effectiveness. Performance is still impaired even when the data structures can fit in the L3 cache [24]. Every core shares this cache instead of the per-core L1 and L2 caches. As a result, L3 is slower and faces cache congestion, such as when another core completes a task that uses the cache and causes cache trashing (up to 90 cycles in modern X86 CPUs) [25].

Search efficiency: Quicker linkages necessitate quick categorization. Assuming a minimum TCP/IP packet size of 40 bytes, 10Gbps networks, for instance, may deliver 31.25 million packets per second [26].

Speed: The ultimate classification decision must be made for each packet. The purpose of categories packets at wire speed within the time permitted for handling a minimum-sized packet is the goal of packet classification. A choice is made in 32 nanoseconds at 10 Gbps OC-192 rates and 40-byte packets. It is difficult to do in practice for a variety of reasons. Setting the minimum packet size is difficult because some unusual packets occasionally come with sizes of 30 bytes or less; nonetheless, other providers aim for a tiny queue to support 64-byte packet payloads and lesser burst sizes. Since packets like TCP, IP, and data link headers are at least 40 bytes, most research employs these sizes. Second, certain packet processing procedures could necessitate numerous lookups, which are technically impossible for small packet sizes to complete at line speed. Handling encapsulated packets and stacking labels on several levels are two examples. Due to this, it may be permissible to relax some of the rigorous wire speed processing constraints for certain applications, such as packet processing (particularly when employing a large classifier); in fact, it seems that this is the case that most core routers nowadays are capable of this [27].

Memory: Memory accesses are used to gauge speed. Wider memory access can frequently reduce the amount of memory access needed. We'll suppose the memory is 32 bits wide. Although we standardize based on several of the algorithms discussed here, the two front-runners, HiCuts and EGT, can benefit from using longer words. We limited our results to 32-bit words [28].

Small storage requirements: Utilizing quick memory technologies like SRAM is made possible by small criteria for storage RAM (Random Access Memory) (Random Access Memory). In contrast to a hardware algorithm, a software algorithm can employ SRAM as an on-chip cache. For semi-custom ASICS, the on-chip SRAM is currently limited to 32 Mbits. A classification algorithm's memory should ideally since it provides the fastest memory, scale with an on-chip SRAM's size (about 1 sec). For instance, RFC's 24 Mbit RFC sizes for a 2800 size table can prevent it from being implemented at high speeds (see findings below). Core routers are often not concerned with the difficulty of updating because rules are frequently not modified very frequently. In contrast, Edge routers with stateful filtering or intrusion detection systems that choose which traffic to monitor on a dynamic basis may need more frequent updates [29].

Capacity: The capacity to manage sizable real-world classifiers.

Quick updates: The data structure must be updated whenever the classifier is modified. Data structures can be divided into two categories: those that must be constructed from scratch each time the classifier is changed and those that can gradually add or delete pieces. Pre-processing is the term we use to describe the process of completely recreating the data structure. The update rate depends on the application; for instance, a firewall that only sometimes has entries manually added may only require a very modest update rate. Alternatively, a router with per-flow queues may need to be updated frequently [30].

Scalability: Scalability of classification-related header fields.

Specification flexibility: Prefixes, operators (such as range, A classification technique should be able to support all comparison operators (less than, more than, equal to, etc.), and wildcards offer greater. Masks that are not continuous may be required in some applications.

1) Consider $R$ - set of rules (The number of rules in the provided dataset)

2) Choose Indicator F. (Packet header fields F shown in Table 1)

3) The Deep Learning (DL) algorithm makes the most accurate predictor A. (Deep Learning classification algorithms)

4) Verify P (Performance measures assessed while using DL algorithms on rule sets) performance.

Applying DL algorithms to obtain the optimal classification model $f\left(r\right)$, which maximizes the accuracy performance measure $p\in P$, will allow one to determine the best classification model to employ about a specific rule set $r\in R$ and five features $f\left(r\right)\in F$. When the source IP address is 210.200.78.134, the destination IP address is 161.34.92.90, the source port is 1024:65535, the destination port is 128, and the protocol is TCP, the proposed approach is used to anticipate the correct rule. The illustration demonstrates how to rule $R2$ is used when it is believed that all five of the provided fields match. The inbound packet with the specified destination is acknowledged and sent on its way because Table 1's action for rule $R2$ is accepted.

Table 1

Sample dataset for analysis
Rules	IP address (source)	IP address (Destination)	Port (source)	Port (Destination)	Protocol	Action taken
R1	67.37.131.206	31.248.24.75	1024:65535	1024:65535	06/000
R2	210.200.78.135	161.35.92.91	1024:65535	128	06/0FF
R3	161.34.54.201	161.34.92.89	1024:65535	1024:65535	06/000	X
R4	162.42.207.72	185.41.102.23	1024:65535	1024:65535	06/0FF
R5	31.131.76.216	29.68.20.37	1024:65535	250	06/0FF	X

We create a deep neural network structure to categorize the packets in this study. The data are prepared before being fed into training neural networks. Common Fig. 1 depicts the system's organizational layout for packet classification. The next sections explain the dataset, implementation, and neural network architecture.

5.1. Dataset

In this work, The typical class bench Has three ACL rule sets: ACL1 _1K, ACL1_ 5K, and ACL1_ 10K. The ACL rule set database classifier was developed using a packet classification technique. The algorithm may leverage the data redundancy in the rules because it is aware of it and because doing so will simplify the problem. Table 1 shows the number of distinct values in the rule set database. The rule size indicates how many rules or pieces of information are contained in each rule set database. A series of rules search through five tuples in this rule set. Each database contains several repeated values and five tuples, each with a distinct value. For example, the rule set ACL1 1K contains 919 total data points, 103 unique and all in the source IP column. The number of distinct values for each field is reported like this. The five components, The source IP address (SIP), the destination IP address (DIP), the source port (SP), the destination port (DP), and the protocol, were chosen from the IPv4 packet header for this packet classification challenge. Each field for SIP and DIP is 32 bits, whereas those for SP and DP are 16 bits, and the protocol is 8 bits. The routers handle each packet by the established rule that it complies with. To train the model, labels are given to each flow. The input layer receives information from all five input fields, while the output layer receives output from each rule's matching flow. Table 1 shows sample data and the input element's inputs and outputs.

5.2. Pre-processing

Real integers are used for all field values. For instance, Source IP address 67.37.131.207 is translated as the source IP address 6737131207 and source port 1024:65535 are written as 1024:65535. The values are transformed similarly for the destination port and IP address. Zero padding is applied to every field to provide an equal length. By normalizing every field, the network's performance is improved. The training examples are derived from particular IPv4 packet header attributes. The remaining 25% of the dataset is divided into testing and training samples. Using the function called split, training and test results are kept apart. Figure 1 displays the distribution's practice samples. The min-max approach normalizes the training data by rescaling each observation with a unit norm. Eq. (1) is utilized in this normalization to scale the data value between 0 and 1.

$$N= \frac{{a}_{i}-\text{min}\left(a\right)}{\text{max}\left(a\right)-\text{min}\left(a\right)}$$

Where, ${a}_{i}$as in the set of input features, $N$ is the normalized data and the minimum values are $min\left(a\right)$ and $max\left(a\right)$ are minimal and maximal values for the provided attributes, respectively. $N$ equals $1$ when ${a}_{i}$ equals max and $0$ when ${a}_{i}$ equals min. It suggests the bare minimum.

Here, minimal ${a}_{i}$ maps to 0 and maximum value maps to $1$. As a result, the minimum and maximum ${a}_{i}$ values are now within the range from 0 to 1. Figure 1 displays the distribution of the data after normalization. After normalization, the data values are transformed into values on a common scale. If certain features don't have values that fall within similar ranges, the gradient in a dense process takes a while to finish before reaching a local or global minimum. We normalized the data in this case to solve the proposed system's learning issue. Once the data have been normalized, the various features take values from similar ranges, hastening the gradient descent's convergence.

5.3. Dense gradient network modelling

The dense network, a family of deep probabilistic models, is what gave rise to the term "dense gradient network" ($DGN$). Restricted Boltzmann Machines (RBMs), a kind of neural network, are the building blocks of $DGN$ [5]. The network features a two-layer topology with no connections inside a layer between binary stochastic $h$ and $v$, which are both visible. We concentrate on the feed-forward architecture shown in Fig. 2 because it is one of many deep learning designs. The fundamental building block of the model, the neuron, is composed of many layers of interconnected neurons in the feed-forward network. There are $N$ training examples with the values $({x}^{1}, {y}^{1}), ({x}^{2}, {y}^{2}),..., ({x}^{n}, {y}^{n})\}$. The feature vector $x$ stores the likelihood that the bit-symbol will occur, and the input vector $y$ represents the class label applied to each occurrence "$1$". The DGN provides the initial weights w while the input vector $\overrightarrow{x}$ moves through the network's visible nodes during training. Our objective is to reduce the cost function $C$.

$$C\left(\overrightarrow{w}, \overrightarrow{x},y\right)= \frac{1}{2} {\left|\left|{h}_{w}\left(\overrightarrow{x}\right)-y\right|\right|}^{2}$$

Where the hypothesis function, ${h}_{w}\left(\overrightarrow{x}\right)$, produces an estimated output. The following are the definitions of the total cost:

$$C\left(\overrightarrow{w}\right)= \frac{1}{N} C\left(\overrightarrow{w}, {\overrightarrow{x}}^{n}, {y}^{n}\right)+ \frac{\lambda }{2}\sum _{k}^{K}\sum _{i}^{{L}_{m}}\sum _{j}^{{L}_{m+1}}{\left({w}_{ij}^{k}\right)}^{2}$$

Here, $K$ is the depth of the network, ${L}_{m}$ is the number of nodes in the ${m}^{th}$ layer, and ${L}_{m}$ is the number of nodes in the ${m}^{th}$ layer. A node $i$ in layer $k-1$ and a node $j$ in layer $k{\prime }s$ weight of their respective edges is given as ${w}_{ij}^{k}\in \overrightarrow{w}$. As a result, we choose the parameter set ${\overrightarrow{w}}^{\text{*}}$ in the following manner to minimize the overall cost function:

$${\overrightarrow{w}}^{*}=\text{arg}\underset{w}{\text{min}}C\left(\overrightarrow{w}\right)$$

Using the backpropagation algorithm, update the weight vectors between the top and bottom layers. Which may be used to calculate the $\overrightarrow{w}$:

$${w}_{ij}^{k}={w}_{ij}^{k-1}+ \zeta \frac{\partial }{\partial {w}_{ij}^{k-1}}C\left(\overrightarrow{w}\right)$$

Where $\zeta$ parameter for adaptation is.

The effort is split into two halves. Prioritize fine-tuning the hyper-parameters first, then look at how these parameters impact $DGN$ performance. The second comparison is between DNN and multilayer perceptrons, support vector machines, and $k$-NN algorithms. TensorFlow serves as the backend, while Python is used to implement all algorithms. The accuracy metric is used to gauge the effectiveness of comparing binary classification to different machine learning techniques and methods already in use. This metric is depicted in Eq. (6) and assesses the discrepancy between expected and actual classes.

$$Accuracy= \frac{Appropriately predicted}{ total predicted}*100$$

6.1. Comparison

With Eq. (6), the expression is used to calculate the accuracy for Table 2 presents each classifier and the comparison outcomes. The results show that KNN, SVM, MLP, and DNN are improved in order of accuracy. It illustrates how better packet classification can be achieved using machine learning techniques. The three ACL datasets' proposed $DGN$ model can improve classification performance throughout training and testing compared to earlier techniques. Some discussions regarding the existing works are provided below:

1) k-NN: It is executed using the scikit-library with the classifier model. The essential hyper-parameter number of k-NN is changed from 1 to 15; while the remaining parameters are considered as default.

2) SVM: It is extensively utilized for classification problems. Here, two kernels like radial bias and linear kernel is utilized. The algorithm is executed with scikit library. While optimizing SVM with using RBF and linear, the hyper-parameters like cost and gamma are concentrated. The cost is selected as ${10}^{4}, {10}^{3}, {10}^{2}, 10, 1$ and ${10}^{4}, {10}^{3}, {10}^{2}, {10}^{1}, 1, {10}^{-1}, {10}^{-2}, {10}^{-3}$. The gamma values are tested for the datasets. For algorithm optimization with RBF kernel, this work attains superior performance than linear one. The highest values is attained across the dataset using cost ($c$) values of 100, 1000 and 10, 000 and gamma ($\gamma$) value is equal to 0.01.

3) MLP: It works in a feed-forward manner and executed in scikit-learn. The classifier function is adopted and the hyper-parameters are modified. It uses hidden layer with 56 neurons and successive epochs are utilized for $ACL1\_K,ACL1\_5K and ACL1\_10K$ where 110 hidden nodes are utilized.

4) DNN: It is executed in Keras with Tensorflow. Open source software’s is utilized to train the network model. The model is trained and the performance is measured against the testing data. With the split function learned from available sklearn package, the dataset is partitioned into testing and training. To eliminate over-fitting issue during the training process, the stopping technique is utilized. This approach stops the training process; when the loss function sets several epochs. Therefore, this approach preserves the network from over-fitting on the training samples. To model the DNN model, the weights are initialized to random values, the bias is set as 0, and the learning rate is 0.1. The relationship among the hidden layers and accuracy performance of packet classification is analyzed.

Table 2

Overall comparisons
Classifier	ACL1_1K		ACL1_5K		ACL1_10K
Classifier	Training	Testing	Training	Testing	Training	Testing
k-NN	89	87	86	85	88	86
SVM	90	90	88	86	89	88
MLP	91	90	89	88	92	90
DNN	95	93	95	92	96	94
DGN	96	95	96	95	97	95

When compared to KNN, SVM, and MLP, For ACL1_ 1K, DNN's training accuracy increases by 5.9%, 4.7%, and 3.9%; for ACL1_ 5K, it increases by 10%, 3%, and 4.3%; and finally, for ACL1_ 10K, it increases by 8%, 6.8%, and 3.6%. Comparable benchmarks include ACL1 _1K, ACL1 _5K, and ACL1 _10K the testing accuracy against KNN, SVM, and MLP is improved by 6.8%, 3.5%, and 2.8%, 7.6%, 5.6%, and 4%, and 7.9%, 6.4%, and 4%, respectively. The total performance of the suggested algorithm in comparison to other methods is shown in Fig. 3 to Fig. 5. $DGN$ can enhance the performance of packet categorization due to the deep learning model's potential for extraction and recognition. Although the current searching methods are more effective at classifying packets, they are still unable to handle the vast majority of classification rules. The proposed $DGN$ model is supposed to be able to handle this issue. Due to automated feature extraction, which significantly reduced the system's cost to identify the features, this $DGN$ model produced the best results for inbound packets.

Here, $DGN$ is used in this paper to classify packets. Deep structure is used to extract the appropriately selected information categories of the packets based on the packet header. The hyper-parameters can be adjusted to improve the classification rate. This classifier further defines the flow for each rule to send the incoming packets based on the action. The results show that $DGN$ has greater packet categorization accuracy than SVM and k-NN models. The suggested method offers a paradigm for managing many categorization rules to increase productivity and reduce system costs for identifying packet attributes. A convolution neural network will be used to enhance the deep learning network classifier further and to identify the flow of packets from new applications that are not yet included in the trained classifier.

Ethics blessing and concurrence to Participate: No participation of humans takes place in this perpetration process
Mortal and Animal Rights: No violation of Human and Animal Rights is involved.
Funding: No backing participates in this work.
Data vacuity statement: Data participating not applicable to this composition as no datasets were generated or anatomized during the current study.
Conflict of Interest: Conflict of Interest is not applicable in this work.
Authorship benefactions: There is no authorship donation
Acknowledgement: There is no acknowledgement involved in this

B. Bischl, M. Lang, L. Kotthoff, J. Schiffner, J. Richter, E. Studerus, G. Casalicchio, and Z. M. Jones. mlr: Machine learning in r. Journal of Machine Learning Research, 17(170):1–5, 2016.
W. Feng, Q. Zhang, G. Hu, and J. X. Huang. Mining network data for intrusion detection through combining SVMs with ant colony networks. Future Generation Computer Systems, 37:127–140, July 2014.
S.-H. Kang and K. J. Kim. A feature selection approach to find optimal feature subsets for the network intrusion detection system. Cluster Computing, 19(1):325–333, January 2016.
B. A. Tama and K. H. Rhee. A combination of PSO-based feature selection and tree-based classifiers ensemble for intrusion detection systems. In Proc. of the Advances in Computer Science and Ubiquitous Computing, volume 373 of Lecture Notes in Electronic Engineering, pages 489–495. Springer, Singapore, 2015.
D. W. Vilela, T. F. Ed’Wilson, A. A. Shinoda, N. V. de Souza Araujo, R. de Oliveira, and V. E. Nascimento. A dataset for evaluating intrusion detection systems in IEEE 802.11 wireless networks. In Proc. of the 2014
G. Wang, J. Hao, J. Ma, and L. Huang. A new approach to intrusion detection using artificial neural networks and fuzzy clustering. Expert systems with applications, 37(9):6225–6232, September 2010.
D. Yu and L. Deng. Deep learning and its applications to signal and information processing [exploratory dsp]. IEEE Signal Processing Magazine, 28(1):145–154, January 2011.
Chen, A. Abraham, and B. Yang. Hybrid flexible neural-tree-based intrusion detection systems. International journal of intelligent systems, 22(4):337–352, February 2007.
S.-H. Kang and K. J. Kim. A feature selection approach to find optimal feature subsets for the network intrusion detection system. Cluster Computing, 19(1):325–333, January 2016.
G. Kim, S. Lee, and S. Kim. A novel hybrid intrusion detection method integrating anomaly detection with misuse detection. Expert Systems with Applications, 41(4):1690–1700, March 2014.
Moustafa and J. Slay. UNSW-NB15: a comprehensive data set for network intrusion detection systems (UNSW-NB15 network data set). In Military Communications and Information Systems Conference (MilCIS’15), Canberra, Australian Capital Territory, Australia, pages 1–6. IEEE, November 2015
Peddabachigari, A. Abraham, C. Grosan, and J. Thomas. Modeling intrusion detection system using hybrid intelligent systems. Journal of network and computer applications, 30(1):114–132, January 2007.
Tama and K.-H. Rhee. Data mining techniques in DoS/DDoS attack detection: A literature review. Information, 18(8):3739–3748, August 2015.
Yasir Zaki, Thomas Pötsch, Jay Chen, Lakshminarayanan Subramanian, and Carmelita Görg. 2015. Adaptive Congestion Control for Unpredictable Cellular Networks. In ACM SIGCOMM
Sherubha, “Graph Based Event Measurement for Analyzing Distributed Anomalies in Sensor Networks”, Sådhanå(Springer), 45:212, https://doi.org/10.1007/s12046-020-01451-w
Sherubha, “An Efficient Network Threat Detection and Classification Method using ANP-MVPS Algorithm in Wireless Sensor Networks”, International Journal of Innovative Technology and Exploring Engineering (IJITEE), ISSN: 2278-3075, Volume-8 Issue-11, September 2019
Sherubha, “An Efficient Intrusion Detection and Authentication Mechanism for Detecting Clone Attack in Wireless Sensor Networks”, Journal of Advanced Research in Dynamical and Control Systems (JARDCS), Volume 11, issue 5, Pg No. 55-68
Changhe Y, Lan J, Xie J, Hu Y (2018) QoS-aware traffic classification architecture using machine learning and deep packet inspection in SDNs. In: International congress of information and communication technology, pp 1209–1216
Dong B, Wang X (2016) Comparing deep learning method to traditional methods using for network intrusion detection. In: IEEE international conference on communication software and networks, pp 581–585
Tang TA, Mhamdi L, McLernon D, Zaidi SAR, Ghogho M (2016) Deep learning approach for network intrusion detection in software defined networking. In: International conference on wireless networks and mobile communications, pp 26–29
R. Ashokan, S. Chandrasekar, “Performance enhancement of Dynamic source routing using simulated annealing in Mobile Ad-hoc networks”, Int. conference on computing, communication and networking, pp. 1-5, 2008.
R. Ashokan, M. Bagyalakshmi, AM. Natarajan, “Design and performance analysis of proxy discovery routing in mobile ad-hoc networks”, International symposium on ad-hoc and ubiquitious computing”, pp. 204-205, 2006.
M. Dharmalingam, B. Umarani, R. Shankar, K. Kumar, “Analysis of Internet of Things in smart manufacturing Industry”, Journal of computational and theoretical nanoscience, Vol. 17, pp. 5495-5502, 2020.
Namdev N, Agrawal S, Silkari S (2015) Recent advancement in machine learning based internet traffic classification. In: International conference on knowledge based and intelligent information and engineering systems, pp 784–791
Mahramian M, Taheri H, Faez K, Yazdani N (2005) Three new neural network based algorithms for IP lookup and packet classification. Iran J Sci Technol B 29:11–22
Lopez-Martin M, Carro B, Sanchez-Esguvillas A, Lloret J (2017) Network traffic classifier with convolutional and recurrent neural networks for internet of things, special section on big data analytics in internet of things and cyber-physical systems. IEEE Access 5:18042–18050
Changhe Y, Lan J, Xie J, Hu Y (2018) QoS-aware traffic classification architecture using machine learning and deep packet inspection in SDNs. In: International congress of information and communication technology, pp 1209–1216
Abadi M, Barham P,Chen J, Chen Z, Davis A, Dean J, Isard M (2016) Tensorflow: a system for large scale machine learning. In: Symposium on operating system design and implementation, pp 265–283
LeCun Y, Bengio Y, Hinton G (2015) Deep learning, review insight. Nature 521:436–444
Tang TA, Mhamdi L, McLernon D, Zaidi SAR, Ghogho M (2016) Deep learning approach for network intrusion detection in software defined networking. In: International conference on wireless networks and mobile communications, pp 26–29

No competing interests reported.

AuthorsBiography.docx

Download PDF

Version 1

posted

You are reading this latest preprint version

An Empirical Study of the Deep Gradient Network Model to Perform Efficient Packet Classification

Status:

Version 1

Abstract

Figures

1. INTRODUCTION

2. RELATED WORKS

3. PERFORMANCE METRICS

4. PROBLEM STATEMENT

5. METHODOLOGY

5.1. Dataset

5.2. Pre-processing

5.3. Dense gradient network modelling

6. RESULT ANALYSIS

6.1. Comparison

7. CONCLUSION

Declarations

References

Additional Declarations

Supplementary Files

Status:

Version 1