Since our purpose is to analyze the EEG dataset with the performance of machine learning techniques, hence we first go through traditional machine learning techniques like decision tree, random forest, extra tree, ridge classifier, logistic regression, KSVM, K-NN, etc. The tree for classification or decision tree is constructed by selecting a specific feature from attributes as the root node using the criteria and split recursively (Mahato and Paul, 2020). Each non-leaf node is labeling with input attribute or feature. Each leaf node is the output or class of the instance or a probability distribution over the different possible classes. Entropy and information gain (IG) are the formulas to select the feature to label the node. Entropy is used for manipulating IG from a feature, whereas IG is used to manipulate the information to gain splitting with the feature. The entropy is defined by (1)entropy = - ∑p(x)log(p(x))
where p(x) stands for the probability of x, log(p(x)) is logarithm of p(x) and the expression for IG is (2)IG(x) = entropy(x) - (weighted average × entropy (children for feature))
where x is the feature & children for feature implies the next nodes or attributes may be considered as parent node to create children or subtree of decision tree.

Some reports also suggest random forest classifier. According to it, subsets of training data set are randomly selected, decision trees are built with it, and to find out the class of an object, we have to aggregate the votes from the all decision tree (Tavares et al., 2019). Thus, in a random forest classifier, the training data are randomly subdivided, and with each sample data, the decision tree is constructed. Extra tree classifier follows the same procedure that random forest classifier follows. The only difference is when splitting the node; we have considered a limited feature in the random forest, whereas, in the case of the extra tree, all features are considered to split a non-leaf node. Generally, it was found out that variance with decision tree classifier is more compared to the random forest, and the variance in the case of random forest classifier is more than an extra tree. The extension of linear regression classifier with minimization of error or loss function is called ridge regression classifier. The loss function can be modified using the Eqn. 3. (3)Loss function = OLS + alpha × ∑(squared coefficient values)
where OLS is the ordinary least square. We have to find out the value of alpha on which performance of the classifier depends. If the value of alpha is less, then it leads to overfitting. On the contrary, if the value of alpha is more, the ridge classifier performance is underfitting (Seifzadeh et al., 2017). Logistic regression can be defined as the probability that an instance with attributes values $x_{1}, x_{2}, ... x_{n}$ is (4) $p=1+\frac{1}{1+e^{-\left(a_0+a_1{x}_1+a_2{x}_2+\dots +a_n{x}_n\right)}}$
where $a_{i}\text{ } i = 0, 1, ... ,$ n are all constants.

From the training data set, which are labeled, we can calculate the constants a_i of the logistic regression equation, and the maximum likelihood estimation technique is used to get the values of constants. Prediction using logistic regression is an easy task, and if the coefficients are accurate, the prediction is robotic (Ilyas et al., 2016). From the mathematical point of view, the SVM classifier is a constrained minimization problem that is solved using the Lagrange multiplier method (Lee et al., 2019). The dot products of support vectors those collected from the training data set are used to find out the classifier, which formulates the maximum gap between different classes of samples. Thus, the product is defined as (5)$L=\sum\limits_{i}\alpha_{i}-\frac{1}{2}\sum\limits_{i}\sum\limits_{j}\alpha_{i}\alpha_{j}y_{i}y_{j}\vec{x}_{i}\vec{x}_{j}$
where ${\alpha }_i$ is the constant generated according to constraints.

To find out the class of a new object $\stackrel{\text{⃗}}{u}$ , the product of the support vector and the new sample has to use for a decision viz., (6) $\sum _i{\alpha }_i{y}_i\stackrel{\text{⃗}}{x_i}.\stackrel{\text{⃗}}{u}+b\ge 0,$ b is the bias value.
If data are not separated or labeled linearly, non-linearly, it is required to separate according to the target class of the instances. This may possibly use kernel tricks. We can generate a hyperplane for the non-linear separable dataset. So, we have to consider mapping function, which transforms the two-dimensional input space into three-dimensional output space. Then for maximizing the classifier SVM and form a decision rule, we have to do the dot product of mapping function for different samples, viz. (7)$L=\sum\limits_{i}\alpha_{i}-\frac{1}{2}\sum\limits_{i}\sum\limits_{j}\alpha_{i}\alpha_{j}y_{i}y_{j}\varphi\text{ }(x_{i})\text{ }\varphi\text{ }(x_{j})$
and the decision rule equation (6) is modified as (8) $\sum\limits_{i}\alpha_{i}y_{i}\varphi\text{ }(x_{i})\text{ }\varphi\text{ }(u)\text{ + }b \ge 0$
We can define a function K as $K\left(x_i,x_j\right)=\phi \left(x_i\right)\mathit{.\phi }\left(x_j\right)$ . Thus, instead of the mapping function, we can use kernel function K, which reduces the complexity of deriving mapping function. Some of the Kernel functions are defined by

(9)$K (x_{i},x_{j})=(x_{i}.x_{j} + 1)^{p}\text{ : Polynomial kernel}$ (10)$K (x_{i},x_{j})=e^{-\gamma(x_{i}\text{ - }x_{j})^{2}}\text{ : RBF kernel}$ (11)$K (x_{i},x_{j})=e^{\frac{-1}{2\sigma^{2}}(x_{i}\text{ - }x_{j})^{2}}\text{ : Gaussian kernel}$

The K-NN algorithm assumes that similar things exist near to each other. K-NN captures the idea of similarity with some mathematics like the distance between points on a graph. K-NN is easy to classify. The goal of any machine learning problem is to find a single model that will best predict our wanted outcome. Rather than making one model and hoping this model is the best/most accurate predictor with traditional machine learning, we can make, ensemble methods take a myriad of models into account, and average or vote those models to produce one final model. The ensemble machine learning techniques are bagging, boosting, and stacking. For implementing bagging classifiers, using the Bootstrapping sampling method, from the data set, random data subsets are formulated where each subset from the original data set is included all the features of the data set. A specified estimator or base classifier, K-NN classifier, KSVM (gaussian) classifier, ridge classifier, logistic regression, decision tree classifier, GNB classifier, polynomial and RBF KSVM classifier, random forest classifier and extra tree classifier are fitted with it. Predictions from each model are combined with average or voting techniques and predict suitable classifiers. We have the weak classifiers that may say traditional classifiers. In the boosting algorithm, the weak classifier is converted into a robust classifier iteratively. Generally, in the case of a weak classifier, the accuracy of classification is low, and to make it high, we readjusted the weight, which is related to the accuracy of classification. The process of adjustment is as follows. The input data which are misclassified have to get more weight, and the inputs which classified correctly have to lose weights. Thus, the procedure emphasizes the misclassified instances.

Ada boost, grad boost, XG boost, etc. are different types of boosting algorithms. Ada boost boosting uses the weak classifier is a decision tree. The weight of each training instance is recorded and accordingly modified as follows. The first weight of the training data $x$ is assigned as 1 / N, where N is the total number of training data set. Then error or misclassified rate is calculated as E = (R - N) / N, where E is the misclassified rate, R is correctly classified training data, and N is the total number of training data set. The weight of the training data is modified as follows: (12)$E=\sum(w_{i}\times t_{i})/\sum w_{i}$
where E is the misclassified rate, w_i is the weight, and t_i is predicted misclassified rate. t_i = 1 if misclassified and t_i = 0 if correctly classified. The parameter or stage value S is manipulated to modify the classifier as in follow: S = ln[(1-E) / E].

Finally, training weights are updated by giving more weight to incorrectly classified and less weight to correctly classified by the following manipulation. w = w × e ^{( s × t_i)}, where w is the weight, e is the Euler number, s is the stage value which is used for weight prediction from the model manipulated using formula s = ln ((1 - error)/error), ln ( ) is the natural logarithm & misclassified error from the model, and t_i is the misclassified rate. The value of t_i manages the weight if the instances are correctly classified. Gradient Boosting (GBM) is also a boosting algorithm that iteratively interpreted a classification tree or decision tree. Suppose we have a decision tree h_m(x) where x is a training instance and the number of leaves j_m. The tree divides the training data into j_m disjoint regions, i.e., $R_{1m},R_{2m},R_{3m},\dots \dots .,R_{j_{m}m}$ and having a constant value b_jm for each region R_jm. Thus for instance $x$, the target is $h_m\left(x\right)=\sum _{j=1}^{j_m}{b}_{\mathit{jm}}{l}_{R_{\mathit{jm}}}\left(x\right)$ . Hence the model is updated as follows: (13) $F_m\left(x\right)=F_{m-1}\left(x\right)+\sum _{j=1}^{\mathit{jm}}{Y}_{\mathit{jm}}{1}_{R_{\mathit{jm}}}\left(x\right)$ (14) $Y_{\mathit{jm}}={}_Y{}^{\mathit{argmin}}\sum _{x_iϵR_{\mathit{jm}}}L\left(y_i,F_{m-1}\left(x_i\right)+Y\right)$
where $F_{m}(x)$ minimizes the expected value of loss function $\text{L }(\text{Y, }F_{m}(x))$. The indicator function of a subset A of a set X is a function 1_A: X → {0, 1}. Y_jm is the constant. The loss function is minimized by multiplying constant Y_jm with b_jm. XGBoost (extreme gradient boosting) is an optimized distributed gradient boosting library and uses the GBM framework at the core and does better than it.

The heterogeneous ensemble learning technique is stacking, which has become a commonly used technique for generating prediction. Using all data set, the base classifiers are trained, and on the next level, a meta classifier is trained, which is based on base classifiers. We can use the decision tree, GNB, K-NN, random forest, extra tree, and logistic regression as the base classifiers to train the dataset. Each model is fine-tuned using probability scores. At the final stage, the predictions of all the base models are combined using majority voting to create a final model called the meta-classifier. Thus, ensemble machine learners are the modified version of traditional machine learning techniques. In bagging, data are split, and a base classifier is implemented with each subset of data and the best one taken as meta-classifier. In the case of boosting, a base classifier is used with the whole dataset and modified the base classifier parameter to get a strong meta-classifier. In the case of stacking, more than one classifier implemented with the data set independently, and the classifier showing the best performance is taken as a meta-classifier. Hence ensemble learner performs better than traditional classifiers (Cacha et al., 2016; Parida et al., 2015).

In Fig. 1, we have summarized overall work in this paper. We have used the epilepsy dataset¹ (¹ http://www.epileptologie-bonn.de/cms/front_content.php?idcat=193&lang=3) freely available (see Andrzejak et al., 2001). The data set recorded from 500 individuals. It is categorized into five sets A, B, C, D, and E. Each set has 100 files representing each file as one subject, and the recording activity of the brain is 23.6 seconds for each subject. In 23.6 s, 4096 sample data points are collected per subject. All details are summarized in Table 1.

Each 4096 sample data points are shuffled and made 23 chunks with 178 data points. Thus, we have 178 attributes and 23 × 500 = 11500 instances. Another attribute y is added to label the target to the instances. The last values fitted for last column y is 1, 2, 3, 4 and 5. 1 represents the recording of EEG signal at the time of epileptic seizure, 2 denotes recording signal where the tumor located, 3 denotes recording of EEG signal from healthy brain area when subject has tumor, 4 means the eyes are closed whereas 5 indicates eye is opened. Thus, we have 179 attributes where 178 are frequencies of EEG signals named X1, X2, …., X178, and another designated as y as the target value. All subjects falling in classes 2, 3, 4, and 5 have no epileptic seizure, whereas subjects in class 1 have an epileptic seizure. Although there are five categories of subjects, we have in intension to classify into two categories, namely class 1 and class 0, where class 1 representing epileptic seizure and class 0 describing non- epileptic seizure. We have used the Pearson coefficient of correlation method to eliminate attributes. Among 178 attributes, we have selected the characteristics whose absolute correlations’ coefficients with labeled attribute “y” have more than 0.025. Basing the coefficient’s criteria, we have 31 attributes to consider. Again, all instances, categorized as five labels, are converted into two as epilepsy seizure and non-epilepsy seizure. The label of example is taken as 1 if it is a category of epilepsy seizure. Otherwise, the category is 0, non-epilepsy seizure.

Before applying the machine learning technique, we may require preprocessing to reduce attributes. Pearson's coefficient of correlation can be used to measure the coefficient of relationship between the attributes and the target class: (15)$r=\frac{Cov(x\text{, }y)}{\sigma_{x}\sigma_{y}}$
where Cov(x,y) is the covariance and ${\sigma }_x$ and ${\sigma }_y$ stand for standard deviations. Higher the absolute value, more the degree of relationship between them.

To manipulate the performance of machine learning techniques cross-validation method or k-fold cross-validation method is suggested. According to the cross-validation procedure, the total data set are divided into two parts training set and testing set. The classifier is trained with the training data set, whereas the performance is tested with the testing data set. For proper evaluation, we can split the datasets into equally K parts, and the classifier is trained for K times. Each classifier is trained with K-1 parts, and another one part is used for testing. Finally, the average is taken of all accuracy predicted by K numbers of tests to get the final accuracy. Evaluation of classifiers is measured by finding accuracy and drawing the receiver operating characteristics’ curve, called the ROC curve. Accuracy can be measured as: (16)$Accuracy=\frac{TP\text{ + }TN}{TP\text{ + }TN\text{ + }FP\text{ + }FN}$
where TP, TN, FP, and FN stand for true positive, true negative, false positive, and false negative, respectively.

For representing the ROC curve of a classifier, the procedure is to be followed with the X-axis represents the false positive rate, and the Y-axis represents the true positive rate, and the threshold values are between 0.0 to 1.0. This fitting of the curve is useful to show the performance of the classifiers and compare them among the classifier performances. Again, the area under the curve summarized the classifier’s skill and hence is a useful tool.