crystal_str_classification_XRD.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
    "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5"
   },
   "outputs": [],
   "source": [
    "# Import libraries\n",
    "\n",
    "import numpy as np # linear algebra\n",
    "import pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n",
    "\n",
    "from pprint import pprint\n",
    "from scipy import constants\n",
    "from scipy import stats\n",
    "from scipy import signal\n",
    "from scipy import fft\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from io import StringIO\n",
    "from numpy import random\n",
    "\n",
    "import plotly.graph_objects as go\n",
    "import seaborn as sns\n",
    "import matplotlib as mpl\n",
    "\n",
    "import requests\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loading datasets, Extracting features and training labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I extracted features using the fact that (sin(theta))^2 values at the peaks in the XRD data are related to h^2+k^2+l^2 values and they need to be an integer. Since here I don't know the lattice parameter and other structural information, I used the ratio of (sin(theta))^2 as my features. Since number of peaks can be different, I used the histogram to get equal feature size for all datas alongwith taking the information of the peaks. In my feature list, the bin size is a variable as it is part of the feature engineering. For random forest classifier, I showed how this feature engineering can come into play.\n",
    "\n",
    "Secondly, sin(theta) values are related with q parameter. Since for XRD we don't know the phase information, it is hard to use Fourier transform to back track the diffraction planes. However, since sin(theta) is related with q and data points are given in 2*theta, I used Discrete Sine Transform (DST) of type 4 to extract another set of parameters. DST transform takes the whole spectrum into account whereas the (sin(theta))^2 takes only the information of the peak locations. Again, for my models I have the option to tune the number of DST coefficients for calculation. As in the random forest classifier, it is shown that number of DST coefficients can also play a role in the model's accuracy.\n",
    "\n",
    "Based on this material properties, I extracted my features and then applied 4 machine learning models. I optimized 4 models (Naive Bayes, KNN, Random Forest Classfier and lightgbm (Gradient boost classifier))."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function for calculating features\n",
    "def calculate_features(data_filepath,nbins_sin2theta_s,strt_bin,end_bin,coeff_num):\n",
    "    # data_filepath: location of csv file containing data for XRD from angle 0.5 to 180 degrees in y0 to y179 columns\n",
    "    #                and labels for bravais lattice in \"bravais_lattice\" column\n",
    "    # nbins_sin2theta_s,strt_bin,end_bin: binning conditions for (sin(theta))^2 from 'strt_bin' to 'end_bin' in 'nbins_sin2theta_s' bins\n",
    "    # coeff_num: number of coefficients of DST transform of XRD data used for classification\n",
    "    # calc_features: list of all features without applying (sin(theta))^2 binning or isolating DST coefficients\n",
    "    # final_feature: dataframe containing list of features that will be used for final classification\n",
    "    \n",
    "    # loading data in dataframe\n",
    "    orig_data=pd.read_csv(data_filepath,na_filter=False)\n",
    "    # isolating columns of the XRD data\n",
    "    orig_features=orig_data.filter(regex='^y')\n",
    "    calc_features=orig_features.copy()\n",
    "    #combination of all intensity data\n",
    "    calc_features['combined_data']=calc_features.values.tolist()\n",
    "\n",
    "    #find the peak indices\n",
    "    calc_features['peak_indices']=calc_features.apply(lambda x: signal.find_peaks(x['combined_data']),axis=1)\n",
    "\n",
    "    #find the peak heights, widths and prominences\n",
    "    calc_features['peak_heights']=calc_features.apply(lambda x: [x['combined_data'][j] for j in x['peak_indices'][0]],axis=1)\n",
    "    calc_features['peak_widths']=calc_features.apply(lambda x: signal.peak_widths(x['combined_data'],x['peak_indices'][0])[0],axis=1)\n",
    "    calc_features['peak_prominences']=calc_features.apply(lambda x: signal.peak_prominences(x['combined_data'],x['peak_indices'][0])[0],axis=1)\n",
    "\n",
    "    # find the corresponding sin(theta), (sin(theta))^2\n",
    "    calc_features['peak_angles (2theta Deg)']=calc_features.apply(lambda x: (x['peak_indices'][0]+1)*0.5,axis=1)\n",
    "    calc_features['sin(theta)_peak']=calc_features.apply(lambda x: np.sin(np.deg2rad(x['peak_angles (2theta Deg)']/2)),axis=1)\n",
    "    calc_features['sin2theta_peak']=calc_features.apply(lambda x: x['sin(theta)_peak']**2,axis=1)\n",
    "\n",
    "    # normalize (sin(theta))^2 based on the first peak as this value corresponds to h^2+k^2+l^2\n",
    "    calc_features['sin2theta_ratio_peak']=calc_features.apply(lambda x: x['sin2theta_peak']/x['sin2theta_peak'][0],axis=1)\n",
    "\n",
    "    # find total number of peak in the XRD data\n",
    "    calc_features['peak_num_tot']=calc_features.apply(lambda x: len(x['peak_heights']),axis=1)\n",
    "\n",
    "    # Calculate statistics of peak heights\n",
    "    calc_features['skew_peak_heights']=calc_features.apply(lambda x: stats.skew(x['peak_heights']),axis=1)\n",
    "    calc_features['kurt_peak_heights']=calc_features.apply(lambda x: stats.kurtosis(x['peak_heights']),axis=1)\n",
    "\n",
    "    # find discrete sin transform coefficients and normalize it\n",
    "    calc_features['dst_4']=calc_features.apply(lambda x: fft.dst(x['combined_data'],type=4),axis=1)\n",
    "    calc_features['dst_4_rat']=calc_features.apply(lambda x: x['dst_4']/abs(x['dst_4'][0]),axis=1)\n",
    "\n",
    "    # convert discrete_sin_transform ration features into dataframe\n",
    "    dst_transform_features=pd.DataFrame(list(calc_features.apply(lambda x: x['dst_4_rat'], axis=1)),columns=[\"DST_coeff_ratio\"+str(j) for j in range(1,181)])\n",
    "\n",
    "    # since ration of (sin(theta))^2 represents the (h,k,l) plane and the maximum value represents the number of symmetry in a way\n",
    "    calc_features['max_sin2theta_ratio_peak']=calc_features.apply(lambda x: max(x['sin2theta_ratio_peak']),axis=1)\n",
    "\n",
    "    # since in two data points there are only 2 peaks, so I used the value of 2nd ratio. For example for CF it should be 1.33, \n",
    "    # for CP it should be 2 and so on. It helps me to identify cubic crystals. Also the ration of total number of peaks to\n",
    "    # (sin(theta))^2 ration can indicate the missing number of (h+k+l). So I added that as a feature.\n",
    "    calc_features['sin2theta_2nd']=calc_features.apply(lambda x: x['sin2theta_ratio_peak'][1],axis=1)\n",
    "    calc_features['ration_totPeak_maxsin2thetaratio']=calc_features.peak_num_tot/calc_features.max_sin2theta_ratio_peak\n",
    "    # add some statistical features of the (sin(theta))^2 ratios\n",
    "    calc_features['mean_sin2theta_ratio_peak']=calc_features.apply(lambda x: np.mean(x['sin2theta_ratio_peak']),axis=1)\n",
    "    calc_features['std_sin2theta_ratio_peak']=calc_features.apply(lambda x: np.std(x['sin2theta_ratio_peak']),axis=1)\n",
    "\n",
    "    # add some statistical features of the peak heights \n",
    "    calc_features['std_peak_heights']=calc_features.apply(lambda x: np.std(x['peak_heights']),axis=1)\n",
    "    calc_features['mean_peak_heights']=calc_features.apply(lambda x: np.mean(x['peak_heights']),axis=1)\n",
    "\n",
    "\n",
    "    # binning (sin(theta))^2 from 'strt_bin' to 'end_bin' in 'nbins_sin2theta_s' bins.\n",
    "    # since number of (sin(theta))^2 values are different for different samples, I am using histogram to get similar number\n",
    "    # of features in all samples. My bin width is 0.333 as in hexagonal, FCC the divide by 3 is important.\n",
    "    # nbins_sin2theta_s=45;strt_bin=1;end_bin=16;\n",
    "    sin2theta_s_stat_feature=pd.DataFrame(list(calc_features.apply(lambda x: np.histogram(x['sin2theta_ratio_peak'],bins=nbins_sin2theta_s,range=(strt_bin,end_bin),density=False)[0],axis=1)),columns=[\"sin2theta_bin\"+str(j) for j in range(nbins_sin2theta_s)])\n",
    "\n",
    "    # number of coefficients that will be considered in the final feature lists from DST transform\n",
    "    #coeff_num=20;\n",
    "\n",
    "    # Construction of final feature dataframe\n",
    "    final_feature=calc_features.loc[:,'max_sin2theta_ratio_peak':]\n",
    "    final_feature=final_feature.join(sin2theta_s_stat_feature)\n",
    "    final_feature=final_feature.join(dst_transform_features.iloc[:,1:coeff_num+1])\n",
    "    \n",
    "    return calc_features, final_feature"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function for extracting labels\n",
    "def extract_labels(data_filepath):\n",
    "    #extract labels from the column 'bravais_lattice' of the csv file located in the 'data_filepath'\n",
    "    # loading data in dataframe\n",
    "    orig_data=pd.read_csv(data_filepath,na_filter=False)\n",
    "    orig_labels=orig_data['bravais_lattice']\n",
    "    return orig_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# location of training data file and kaggle data file\n",
    "training_data_filepath=\"C:\\\\Users\\\\Raihan\\\\Nano281_project\\\\cod_xrd_42k.csv\"\n",
    "kaggle_data_filepath=\"C:\\\\Users\\\\Raihan\\\\Nano281_project\\\\test.csv\"\n",
    "\n",
    "# feature size can be varied based on the binning parameters and number of DST coefficients.\n",
    "# For model optimization the following parameters are used. Later it will be varied to get the\n",
    "# optimum performance of different models\n",
    "\n",
    "nbin_sin2theta=45;start_bin=1;end_bin=16;dst_coeff=20;\n",
    "# calculate features for training dataset (cod_xrd_42k.csv)\n",
    "base_feature_training,final_feature_training_45_20=calculate_features(training_data_filepath,nbin_sin2theta,start_bin,end_bin,dst_coeff)\n",
    "\n",
    "# calculate features for kaggle dataset (test.csv)\n",
    "base_feature_kaggle,final_feature_kaggle_45_20=calculate_features(kaggle_data_filepath,nbin_sin2theta,start_bin,end_bin,dst_coeff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# extract training labels and encode labels in numerical values\n",
    "from sklearn import preprocessing\n",
    "orig_labels=extract_labels(training_data_filepath)\n",
    "le = preprocessing.LabelEncoder()\n",
    "le.fit(orig_labels)\n",
    "original_labels = le.transform(orig_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data pre-processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Splitting training data with 10% unseen data for model validation\n",
    "from sklearn.model_selection import train_test_split\n",
    "x_train_45_20, x_test_45_20, y_train_45_20, y_test_45_20 = train_test_split(final_feature_training_45_20, original_labels, test_size=0.1, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scaling data for better model performance\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "minmax_scaler=MinMaxScaler()\n",
    "\n",
    "minmax_scaler_45_20=minmax_scaler\n",
    "minmax_scaler_45_20.fit(x_train_45_20)\n",
    "x_test_scaled_45_20=minmax_scaler_45_20.transform(x_test_45_20)\n",
    "x_train_scaled_45_20=minmax_scaler_45_20.transform(x_train_45_20)\n",
    "kaggle_scaled_45_20=minmax_scaler_45_20.transform(final_feature_kaggle_45_20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Model Selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# functions for plotting the grid search values\n",
    "from sklearn.metrics import mean_squared_error, accuracy_score, roc_curve, roc_auc_score\n",
    "from sklearn.model_selection import GridSearchCV, KFold, StratifiedKFold\n",
    "def plot_grid_search_results(gs, plot_type='bar', ylim=None):\n",
    "    \"\"\"\n",
    "    Plots the results of GridSearchCV.\n",
    "    \"\"\"\n",
    "    results = pd.DataFrame(gs.cv_results_)\n",
    "    for c in results.columns:\n",
    "        # Note that here we are working with just variations in one parameter.\n",
    "        # So we can automatically find the name of that parameter.\n",
    "        if c.startswith(\"param_\"):\n",
    "            x = c\n",
    "            break\n",
    "    results = results.melt(id_vars=[x], value_vars=['mean_train_score', 'mean_test_score'],\n",
    "        var_name=\"type\", value_name='score')\n",
    "    fig, ax = plt.subplots(figsize=(16, 8))\n",
    "    if plot_type == \"bar\":\n",
    "        ax = sns.barplot(x=x, y=\"score\", hue='type', data=results)\n",
    "    else:\n",
    "        ax = sns.scatterplot(x=x, y=\"score\", hue='type', data=results)\n",
    "    plt.xlabel(x)\n",
    "    if ylim:\n",
    "        plt.ylim(ylim)\n",
    "    return fig\n",
    "\n",
    "def plot_grid_search_results2(gs, ylim=None):\n",
    "    \"\"\"\n",
    "    Plots the results of GridSearchCV.\n",
    "    \n",
    "    Args:\n",
    "        gs: A GridSearchCV object.\n",
    "        ylim: Optional setting for y limits.\n",
    "    \"\"\"\n",
    "    results = pd.DataFrame(gs.cv_results_)\n",
    "    for c in results.columns:\n",
    "        # Note that here we are working with just variations in one parameter.\n",
    "        # So we can automatically find the name of that parameter.\n",
    "        if c.startswith(\"param_\"):\n",
    "            x = c\n",
    "            break\n",
    "    fig, ax = plt.subplots(figsize=(12, 6))    \n",
    "    ax = sns.lineplot(x=x, y=\"mean_train_score\", data=results)\n",
    "    ax = sns.scatterplot(x=x, y=\"mean_train_score\", data=results, marker='x')\n",
    "    ax = sns.lineplot(x=x, y=\"mean_test_score\", data=results)\n",
    "    ax = sns.scatterplot(x=x, y=\"mean_test_score\", data=results, marker='o')\n",
    "    plt.xlabel(x)\n",
    "    if ylim:\n",
    "        plt.ylim(ylim)\n",
    "    ax.legend([\"Train\", \"Test\"], loc=2);\n",
    "    \n",
    "def plotly_grid_search_results(gs, plot_type='bar', ylim=None):\n",
    "    \"\"\"\n",
    "    Plots the results of GridSearchCV.\n",
    "    \"\"\"\n",
    "    results = pd.DataFrame(gs.cv_results_)\n",
    "    for c in results.columns:\n",
    "        # Note that here we are working with just variations in one parameter.\n",
    "        # So we can automatically find the name of that parameter.\n",
    "        if c.startswith(\"param_\"):\n",
    "            x = c\n",
    "            break\n",
    "    results = pd.DataFrame(gs.cv_results_)\n",
    "    if plot_type == \"bar\":\n",
    "        xval = [\"(%s)\" % l if not isinstance(l, tuple) else str(l) for l in results[x]]\n",
    "        fig = go.Figure(data=[\n",
    "            go.Bar(name='Train', x=xval, y=results['mean_train_score']),\n",
    "            go.Bar(name='Test', x=xval, y=results['mean_test_score'])\n",
    "        ])\n",
    "        fig.update_layout(barmode='group')\n",
    "    else:\n",
    "        fig = go.Figure(data=[\n",
    "            go.Scatter(name='Train', x=results[x], y=results['mean_train_score']),\n",
    "            go.Scatter(name='Test', x=results[x], y=results['mean_test_score'])\n",
    "        ])\n",
    "    fig.update_xaxes(title_text=x)\n",
    "    fig.update_yaxes(title_text='Score')\n",
    "    return fig\n",
    "    \n",
    "kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Naive Bayes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two different types of Naive Bayes algorithm are tried. One is the categoricalNB and another is the GaussianNB."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.11596513605442177, 0.10760401721664276)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.naive_bayes import CategoricalNB, GaussianNB\n",
    "\n",
    "# CategoricalNB\n",
    "cnb = CategoricalNB()\n",
    "cnb.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "y_pred_train_cnb = cnb.predict(x_train_scaled_45_20)\n",
    "y_pred_test_cnb = cnb.predict(x_test_scaled_45_20)\n",
    "accuracy_train_cnb=(y_train_45_20 == y_pred_train_cnb).sum()/x_train_scaled_45_20.shape[0]\n",
    "accuracy_test_cnb=(y_test_45_20 == y_pred_test_cnb).sum()/x_test_scaled_45_20.shape[0]\n",
    "\n",
    "accuracy_train_cnb,accuracy_test_cnb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Initial accuracty for categoricalNB is very low. Instead of optimizing this model I used GaussianNB model next"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.30747767857142855, 0.2996174079387853)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gnb = GaussianNB()\n",
    "gnb.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "y_pred_train_gnb = gnb.predict(x_train_scaled_45_20)\n",
    "y_pred_test_gnb = gnb.predict(x_test_scaled_45_20)\n",
    "accuracy_train_gnb=(y_train_45_20 == y_pred_train_gnb).sum()/x_train_scaled_45_20.shape[0]\n",
    "accuracy_test_gnb=(y_test_45_20 == y_pred_test_gnb).sum()/x_test_scaled_45_20.shape[0]\n",
    "\n",
    "accuracy_train_gnb,accuracy_test_gnb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The accuracy of the GaussianNB is about 29.96% for the model validation. I try to optimize the model next."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "gs = GridSearchCV(\n",
    "    gnb,\n",
    "    param_grid={\"var_smoothing\": np.logspace(-11, -1, 11)},\n",
    "    return_train_score=True,\n",
    "    scoring=\"accuracy\",\n",
    "    cv=kfold,\n",
    ")\n",
    "\n",
    "gs.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "plot_grid_search_results2(gs)\n",
    "plt.ylabel(\"accuracy\");plt.xscale(\"log\")\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The maximum accuracy can be achieved with the var_smoothing=1e-3 for this classifier and the accuracy of the cross validated testing data is around 31%. To further prove this, the model is run again with the optimized parameter and accuracy for the unseen data is calculated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.3138020833333333, 0.30416068866571017)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gnb = GaussianNB(var_smoothing=1e-3)\n",
    "gnb.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "y_pred_train_gnb = gnb.predict(x_train_scaled_45_20)\n",
    "y_pred_test_gnb = gnb.predict(x_test_scaled_45_20)\n",
    "accuracy_train_gnb=(y_train_45_20 == y_pred_train_gnb).sum()/x_train_scaled_45_20.shape[0]\n",
    "accuracy_test_gnb=(y_test_45_20 == y_pred_test_gnb).sum()/x_test_scaled_45_20.shape[0]\n",
    "\n",
    "accuracy_train_gnb,accuracy_test_gnb"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The accuracy of the GaussianNB model with the unseen data is 30.42%"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## kNN Classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For kNN Classifier, at first the model was built with defuault parameters (n_neighbors=5 and p=2). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.6003401360544217, 0.42802486848397897)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "knn = KNeighborsClassifier(n_jobs=-1)\n",
    "knn.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "y_pred_train_knn = knn.predict(x_train_scaled_45_20)\n",
    "y_pred_test_knn = knn.predict(x_test_scaled_45_20)\n",
    "accuracy_train_knn=(y_train_45_20 == y_pred_train_knn).sum()/x_train_scaled_45_20.shape[0]\n",
    "accuracy_test_knn=(y_test_45_20 == y_pred_test_knn).sum()/x_test_scaled_45_20.shape[0]\n",
    "accuracy_train_knn, accuracy_test_knn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The accuracy is not that high but it is higher than Gaussian Naive Bayes method. Therefore, I will optimize this method too. Before running the cross validation, I tried to optimize the p value at first."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.6271789965986394, 0.46293639406982307)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "knn = KNeighborsClassifier(n_jobs=-1,p=1)\n",
    "knn.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "y_pred_train_knn = knn.predict(x_train_scaled_45_20)\n",
    "y_pred_test_knn = knn.predict(x_test_scaled_45_20)\n",
    "accuracy_train_knn=(y_train_45_20 == y_pred_train_knn).sum()/x_train_scaled_45_20.shape[0]\n",
    "accuracy_test_knn=(y_test_45_20 == y_pred_test_knn).sum()/x_test_scaled_45_20.shape[0]\n",
    "accuracy_train_knn, accuracy_test_knn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since accuracy is higher for p=1 (46.29% compared to 42.8%) with default n_neighbors=5, I will n_neighbors with p=1. Since accuracy of the testing data is totally for an unseen data, I use that score to optimize the model.\n",
    "\n",
    "Next, I will vary the n_neighbors to 3 and 8 to check the direction of the accuracy with the model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.5780984268707483, 0.453610712577714)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# n_neighbors=8\n",
    "knn = KNeighborsClassifier(n_jobs=-1,p=1,n_neighbors=8)\n",
    "knn.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "y_pred_train_knn = knn.predict(x_train_scaled_45_20)\n",
    "y_pred_test_knn = knn.predict(x_test_scaled_45_20)\n",
    "accuracy_train_knn=(y_train_45_20 == y_pred_train_knn).sum()/x_train_scaled_45_20.shape[0]\n",
    "accuracy_test_knn=(y_test_45_20 == y_pred_test_knn).sum()/x_test_scaled_45_20.shape[0]\n",
    "accuracy_train_knn, accuracy_test_knn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.6696428571428571, 0.4581539933046389)"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# n_neighbors=3\n",
    "knn = KNeighborsClassifier(n_jobs=-1,p=1,n_neighbors=3)\n",
    "knn.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "y_pred_train_knn = knn.predict(x_train_scaled_45_20)\n",
    "y_pred_test_knn = knn.predict(x_test_scaled_45_20)\n",
    "accuracy_train_knn=(y_train_45_20 == y_pred_train_knn).sum()/x_train_scaled_45_20.shape[0]\n",
    "accuracy_test_knn=(y_test_45_20 == y_pred_test_knn).sum()/x_test_scaled_45_20.shape[0]\n",
    "accuracy_train_knn, accuracy_test_knn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Therefore, it is evident that the optimized model for knn is with n_neighbors=5 and p=1. The final model is"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.6271789965986394, 0.46293639406982307)"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "knn = KNeighborsClassifier(n_jobs=-1,p=1,n_neighbors=5)\n",
    "knn.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "y_pred_train_knn = knn.predict(x_train_scaled_45_20)\n",
    "y_pred_test_knn = knn.predict(x_test_scaled_45_20)\n",
    "accuracy_train_knn=(y_train_45_20 == y_pred_train_knn).sum()/x_train_scaled_45_20.shape[0]\n",
    "accuracy_test_knn=(y_test_45_20 == y_pred_test_knn).sum()/x_test_scaled_45_20.shape[0]\n",
    "accuracy_train_knn, accuracy_test_knn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With KNN classifier the accuracy of the unseen test data is 46.3%"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Forest Classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since none of the above methods give a good accuracy, I used random forest classifier at next. This follows ensemble method for classification."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using default parameters at first \n",
    "# Default:(n_estimators=100,criterion=\"gini\",ccp_alpha=0, max_features='sqrt', min_samples_leaf=1, min_samples_split=2)\n",
    "rf1=RandomForestClassifier(random_state=0, n_jobs=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "rf1_45=rf1\n",
    "rf1_45.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "y_pred_train_rf1_45 = rf1_45.predict(x_train_scaled_45_20)\n",
    "y_pred_test_rf1_45 = rf1_45.predict(x_test_scaled_45_20)\n",
    "accuracy_train_rf=(y_train_45_20 == y_pred_train_rf1_45).sum()/x_train_scaled_45_20.shape[0]\n",
    "accuracy_test_rf=(y_test_45_20 == y_pred_test_rf1_45).sum()/x_test_scaled_45_20.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0, 0.5758010521281683)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_train_rf, accuracy_test_rf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the defulat hyper-parameters, train accuracy is 100% and validation score with unseen data is 57.58%. Next I tried to optimize the hyperparameters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At first, I tried to optimize the number of estimators via grid search."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rf1=RandomForestClassifier(random_state=0, n_jobs=-1)\n",
    "gs = GridSearchCV(\n",
    "    rf1,\n",
    "    param_grid={\"n_estimators\": np.array([10, 100, 500, 1000])},\n",
    "    return_train_score=True,\n",
    "    scoring=\"accuracy\",\n",
    "    cv=kfold\n",
    ")\n",
    "\n",
    "gs.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "plot_grid_search_results2(gs)\n",
    "plt.ylabel(\"accuracy\");\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.49952173, 0.56042735, 0.57358102, 0.57342161])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs.cv_results_.get('mean_test_score')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The maximum accuracty is found when n_estimators = 500. Therefore I will use this value for next optimization of ccp_alpha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rf1=RandomForestClassifier(random_state=0, n_jobs=-1,n_estimators=500)\n",
    "gs = GridSearchCV(\n",
    "    rf1,\n",
    "    param_grid={\"ccp_alpha\": np.array([1e-16, 1e-10, 1e-6, 1e-2])},\n",
    "    return_train_score=True,\n",
    "    scoring=\"accuracy\",\n",
    "    cv=kfold\n",
    ")\n",
    "\n",
    "gs.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "plot_grid_search_results2(gs)\n",
    "plt.ylabel(\"accuracy\");plt.xscale('log');\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.57358102, 0.57358102, 0.57358102, 0.25029229])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs.cv_results_.get('mean_test_score')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The maximum accuracty is found when ccp_alpha<=1e-6. Therefore, I used ccp_alpha=1e-10 for the next level of optimization of criterion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rf1=RandomForestClassifier(random_state=0, n_jobs=-1,n_estimators=500,ccp_alpha=1e-10)\n",
    "gs = GridSearchCV(\n",
    "    rf1,\n",
    "    param_grid={\"criterion\": [\"entropy\", \"gini\"]},\n",
    "    return_train_score=True,\n",
    "    scoring=\"accuracy\",\n",
    "    cv=kfold\n",
    ")\n",
    "\n",
    "gs.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "plot_grid_search_results2(gs)\n",
    "plt.ylabel(\"accuracy\");\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.5749628 , 0.57358102])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs.cv_results_.get('mean_test_score')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since 'criterion' = 'entropy' gives higher accuracy, this is selected for next level of optimization. Since I changed the parameters, I am checking the accuracy with n_estimators=1000 next as previously they gave almost similar accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0, 0.5920612147297943)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf1=RandomForestClassifier(random_state=0, n_jobs=-1,n_estimators=1000,ccp_alpha=1e-10,criterion=\"entropy\")\n",
    "\n",
    "rf1_45=rf1\n",
    "rf1_45.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "y_pred_train_rf1_45 = rf1_45.predict(x_train_scaled_45_20)\n",
    "y_pred_test_rf1_45 = rf1_45.predict(x_test_scaled_45_20)\n",
    "accuracy_train_rf=(y_train_45_20 == y_pred_train_rf1_45).sum()/x_train_scaled_45_20.shape[0]\n",
    "accuracy_test_rf=(y_test_45_20 == y_pred_test_rf1_45).sum()/x_test_scaled_45_20.shape[0]\n",
    "accuracy_train_rf,accuracy_test_rf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For unseen data with n_estimators=1000, validation accuracy is 59.2% which is higher than 57.5% with n_estimators=500. Therefore, I used n_estimators=1000 for optimization of max_features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rf1=RandomForestClassifier(random_state=0, n_jobs=-1,n_estimators=1000,ccp_alpha=1e-10,criterion=\"entropy\")\n",
    "gs = GridSearchCV(\n",
    "    rf1,\n",
    "    param_grid={\"max_features\": [\"sqrt\", \"log2\"]},\n",
    "    return_train_score=True,\n",
    "    scoring=\"accuracy\",\n",
    "    cv=kfold\n",
    ")\n",
    "\n",
    "gs.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "plot_grid_search_results2(gs)\n",
    "plt.ylabel(\"accuracy\");\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.57583983, 0.57089721])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs.cv_results_.get('mean_test_score')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since 'max_features' = 'sqrt' gives higher accuracy, this is selected for next optimization of min_samples_leaf and min_samples_split. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rf1=RandomForestClassifier(random_state=0, n_jobs=-1,n_estimators=1000,ccp_alpha=1e-10,criterion=\"entropy\")\n",
    "gs = GridSearchCV(\n",
    "    rf1,\n",
    "    param_grid={\"min_samples_leaf\": [1, 2], \"min_samples_split\": [2, 5]},\n",
    "    return_train_score=True,\n",
    "    scoring=\"accuracy\",\n",
    "    cv=kfold\n",
    ")\n",
    "\n",
    "gs.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "plot_grid_search_results2(gs)\n",
    "plt.ylabel(\"accuracy\");\n",
    "plt.grid(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.57583983, 0.56975452, 0.56946228, 0.56709715])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gs.cv_results_.get('mean_test_score')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since the variation in min_samples_leaf and min_samples_split don't increase the accuracy from the deafult values of those, I kept those values at the default. Now, Random Forest Classifier has a parameter called oob_score for generalization of the accuracy. I used that for the final model. Therefore the final model with this feature size is give beolow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "rf1=RandomForestClassifier(oob_score=True, random_state=0,n_estimators=1000,criterion=\"entropy\",ccp_alpha=1e-10, max_features='sqrt', min_samples_leaf=1, min_samples_split=2, n_jobs=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0, 0.5920612147297943)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf1_45=rf1\n",
    "rf1_45.fit(x_train_scaled_45_20, y_train_45_20)\n",
    "y_pred_train_rf1_45 = rf1_45.predict(x_train_scaled_45_20)\n",
    "y_pred_test_rf1_45 = rf1_45.predict(x_test_scaled_45_20)\n",
    "accuracy_train_rf=(y_train_45_20 == y_pred_train_rf1_45).sum()/x_train_scaled_45_20.shape[0]\n",
    "accuracy_test_rf=(y_test_45_20 == y_pred_test_rf1_45).sum()/x_test_scaled_45_20.shape[0]\n",
    "accuracy_train_rf, accuracy_test_rf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5848214285714286"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf1_45.oob_score_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even though cross-validation score was 57.5%, with the unseen data the accuracy is 59.5%. Since I activated oob_score for the classifier, I used that for the model accuracy. Therefore, accuracy of this model with 45 bins of (sin(theta))^2 feature and 20 coefficient of DST transform is 58.48%."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, I will just vary the feature size to check whether the accuracy can be increased. oob_score will be used for model accuracy. \n",
    "At first I will vary the number of DST coefficients from 25 to 40 with a step of 5 and then check their oob_score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0, 0.5951697752271641, 0.5871598639455783)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 25 DST coefficients\n",
    "# feature extraction \n",
    "nbin_sin2theta=45;start_bin=1;end_bin=16;dst_coeff=25;\n",
    "base_feature_training,final_feature_training_45_25=calculate_features(training_data_filepath,nbin_sin2theta,start_bin,end_bin,dst_coeff)\n",
    "# train-test split\n",
    "x_train_45_25, x_test_45_25, y_train_45_25, y_test_45_25 = train_test_split(final_feature_training_45_25, original_labels, test_size=0.1, random_state=0)\n",
    "#data scaling\n",
    "minmax_scaler_45_25=minmax_scaler\n",
    "minmax_scaler_45_25.fit(x_train_45_25)\n",
    "x_test_scaled_45_25=minmax_scaler_45_25.transform(x_test_45_25)\n",
    "x_train_scaled_45_25=minmax_scaler_45_25.transform(x_train_45_25)\n",
    "# model \n",
    "rf1_45_25=rf1\n",
    "rf1_45_25.fit(x_train_scaled_45_25, y_train_45_25)\n",
    "y_pred_train_rf1_45_25 = rf1_45_25.predict(x_train_scaled_45_25)\n",
    "y_pred_test_rf1_45_25 = rf1_45_25.predict(x_test_scaled_45_25)\n",
    "accuracy_train_rf=(y_train_45_25 == y_pred_train_rf1_45_25).sum()/x_train_scaled_45_25.shape[0]\n",
    "accuracy_test_rf=(y_test_45_25 == y_pred_test_rf1_45_25).sum()/x_test_scaled_45_25.shape[0]\n",
    "# Accuracies\n",
    "accuracy_train_rf, accuracy_test_rf, rf1_45_25.oob_score_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0, 0.5913438546150167, 0.5882227891156463)"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 30 DST coefficients\n",
    "# feature extraction \n",
    "nbin_sin2theta=45;start_bin=1;end_bin=16;dst_coeff=30;\n",
    "base_feature_training,final_feature_training_45_30=calculate_features(training_data_filepath,nbin_sin2theta,start_bin,end_bin,dst_coeff)\n",
    "# train-test split\n",
    "x_train_45_30, x_test_45_30, y_train_45_30, y_test_45_30 = train_test_split(final_feature_training_45_30, original_labels, test_size=0.1, random_state=0)\n",
    "#data scaling\n",
    "minmax_scaler_45_30=minmax_scaler\n",
    "minmax_scaler_45_30.fit(x_train_45_30)\n",
    "x_test_scaled_45_30=minmax_scaler_45_30.transform(x_test_45_30)\n",
    "x_train_scaled_45_30=minmax_scaler_45_30.transform(x_train_45_30)\n",
    "# model \n",
    "rf1_45_30=rf1\n",
    "rf1_45_30.fit(x_train_scaled_45_30, y_train_45_30)\n",
    "y_pred_train_rf1_45_30 = rf1_45_30.predict(x_train_scaled_45_30)\n",
    "y_pred_test_rf1_45_30 = rf1_45_30.predict(x_test_scaled_45_30)\n",
    "accuracy_train_rf=(y_train_45_30 == y_pred_train_rf1_45_30).sum()/x_train_scaled_45_30.shape[0]\n",
    "accuracy_test_rf=(y_test_45_30 == y_pred_test_rf1_45_30).sum()/x_test_scaled_45_30.shape[0]\n",
    "# Accuracies\n",
    "accuracy_train_rf, accuracy_test_rf, rf1_45_30.oob_score_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0, 0.5980392156862745, 0.5871598639455783)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 35 DST coefficients\n",
    "# feature extraction \n",
    "nbin_sin2theta=45;start_bin=1;end_bin=16;dst_coeff=35;\n",
    "base_feature_training,final_feature_training_45_35=calculate_features(training_data_filepath,nbin_sin2theta,start_bin,end_bin,dst_coeff)\n",
    "# train-test split\n",
    "x_train_45_35, x_test_45_35, y_train_45_35, y_test_45_35 = train_test_split(final_feature_training_45_35, original_labels, test_size=0.1, random_state=0)\n",
    "#data scaling\n",
    "minmax_scaler_45_35=minmax_scaler\n",
    "minmax_scaler_45_35.fit(x_train_45_35)\n",
    "x_test_scaled_45_35=minmax_scaler_45_35.transform(x_test_45_35)\n",
    "x_train_scaled_45_35=minmax_scaler_45_35.transform(x_train_45_35)\n",
    "# model \n",
    "rf1_45_35=rf1\n",
    "rf1_45_35.fit(x_train_scaled_45_35, y_train_45_35)\n",
    "y_pred_train_rf1_45_35 = rf1_45_35.predict(x_train_scaled_45_35)\n",
    "y_pred_test_rf1_45_35 = rf1_45_35.predict(x_test_scaled_45_35)\n",
    "accuracy_train_rf=(y_train_45_35 == y_pred_train_rf1_45_35).sum()/x_train_scaled_45_35.shape[0]\n",
    "accuracy_test_rf=(y_test_45_35 == y_pred_test_rf1_45_35).sum()/x_test_scaled_45_35.shape[0]\n",
    "# Accuracies\n",
    "accuracy_train_rf, accuracy_test_rf, rf1_45_35.oob_score_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0, 0.592778574844572, 0.5862829506802721)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 40 DST coefficients\n",
    "# feature extraction \n",
    "nbin_sin2theta=45;start_bin=1;end_bin=16;dst_coeff=40;\n",
    "base_feature_training,final_feature_training_45_40=calculate_features(training_data_filepath,nbin_sin2theta,start_bin,end_bin,dst_coeff)\n",
    "# train-test split\n",
    "x_train_45_40, x_test_45_40, y_train_45_40, y_test_45_40 = train_test_split(final_feature_training_45_40, original_labels, test_size=0.1, random_state=0)\n",
    "#data scaling\n",
    "minmax_scaler_45_40=minmax_scaler\n",
    "minmax_scaler_45_40.fit(x_train_45_40)\n",
    "x_test_scaled_45_40=minmax_scaler_45_40.transform(x_test_45_40)\n",
    "x_train_scaled_45_40=minmax_scaler_45_40.transform(x_train_45_40)\n",
    "# model \n",
    "rf1_45_40=rf1\n",
    "rf1_45_40.fit(x_train_scaled_45_40, y_train_45_40)\n",
    "y_pred_train_rf1_45_40 = rf1_45_40.predict(x_train_scaled_45_40)\n",
    "y_pred_test_rf1_45_40 = rf1_45_40.predict(x_test_scaled_45_40)\n",
    "accuracy_train_rf=(y_train_45_40 == y_pred_train_rf1_45_40).sum()/x_train_scaled_45_40.shape[0]\n",
    "accuracy_test_rf=(y_test_45_40 == y_pred_test_rf1_45_40).sum()/x_test_scaled_45_40.shape[0]\n",
    "# Accuracies\n",
    "accuracy_train_rf, accuracy_test_rf, rf1_45_40.oob_score_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "OOB scores are 58.48%, 58.72%, 58.82%, 58.72% and 58.63% for 20, 25, 30, 35 and 40 DST coefficients respectively. Therefore 30 considering 30 DST coefficents for the feature size is optimal. Next we will try to optimize the binning of (sin(theta))^2 by varrying the end bin from 30 to 60 with endbin from 11 to 21 as we optimized the previous model by end bin = 16."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0, 0.5951697752271641, 0.5887011054421769)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 30 DST coefficients & 30 bins\n",
    "# feature extraction \n",
    "nbin_sin2theta=30;start_bin=1;end_bin=11;dst_coeff=30;\n",
    "base_feature_training,final_feature_training_30_30=calculate_features(training_data_filepath,nbin_sin2theta,start_bin,end_bin,dst_coeff)\n",
    "# train-test split\n",
    "x_train_30_30, x_test_30_30, y_train_30_30, y_test_30_30 = train_test_split(final_feature_training_30_30, original_labels, test_size=0.1, random_state=0)\n",
    "#data scaling\n",
    "minmax_scaler_30_30=minmax_scaler\n",
    "minmax_scaler_30_30.fit(x_train_30_30)\n",
    "x_test_scaled_30_30=minmax_scaler_30_30.transform(x_test_30_30)\n",
    "x_train_scaled_30_30=minmax_scaler_30_30.transform(x_train_30_30)\n",
    "# model \n",
    "rf1_30_30=RandomForestClassifier(oob_score=True, random_state=0,n_estimators=1000,criterion=\"entropy\",ccp_alpha=1e-10, max_features='sqrt', min_samples_leaf=1, min_samples_split=2, n_jobs=-1)\n",
    "rf1_30_30.fit(x_train_scaled_30_30, y_train_30_30)\n",
    "y_pred_train_rf1_30_30 = rf1_30_30.predict(x_train_scaled_30_30)\n",
    "y_pred_test_rf1_30_30 = rf1_30_30.predict(x_test_scaled_30_30)\n",
    "accuracy_train_rf=(y_train_30_30 == y_pred_train_rf1_30_30).sum()/x_train_scaled_30_30.shape[0]\n",
    "accuracy_test_rf=(y_test_30_30 == y_pred_test_rf1_30_30).sum()/x_test_scaled_30_30.shape[0]\n",
    "# Accuracies\n",
    "accuracy_train_rf, accuracy_test_rf, rf1_30_30.oob_score_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0, 0.5877570540411287, 0.5817389455782312)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 30 DST coefficients & 60 bins\n",
    "# feature extraction \n",
    "nbin_sin2theta=60;start_bin=1;end_bin=21;dst_coeff=30;\n",
    "base_feature_training,final_feature_training_60_30=calculate_features(training_data_filepath,nbin_sin2theta,start_bin,end_bin,dst_coeff)\n",
    "# train-test split\n",
    "x_train_60_30, x_test_60_30, y_train_60_30, y_test_60_30 = train_test_split(final_feature_training_60_30, original_labels, test_size=0.1, random_state=0)\n",
    "#data scaling\n",
    "minmax_scaler_60_30=minmax_scaler\n",
    "minmax_scaler_60_30.fit(x_train_60_30)\n",
    "x_test_scaled_60_30=minmax_scaler_60_30.transform(x_test_60_30)\n",
    "x_train_scaled_60_30=minmax_scaler_60_30.transform(x_train_60_30)\n",
    "# model \n",
    "rf1_60_30=rf1\n",
    "rf1_60_30.fit(x_train_scaled_60_30, y_train_60_30)\n",
    "y_pred_train_rf1_60_30 = rf1_60_30.predict(x_train_scaled_60_30)\n",
    "y_pred_test_rf1_60_30 = rf1_60_30.predict(x_test_scaled_60_30)\n",
    "accuracy_train_rf=(y_train_60_30 == y_pred_train_rf1_60_30).sum()/x_train_scaled_60_30.shape[0]\n",
    "accuracy_test_rf=(y_test_60_30 == y_pred_test_rf1_60_30).sum()/x_test_scaled_60_30.shape[0]\n",
    "# Accuracies\n",
    "accuracy_train_rf, accuracy_test_rf, rf1_60_30.oob_score_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is evident from the OOB scores that 30 and 45 bins of (sin(theta))^2 gives almost same result and 60 bins has lower OOB score. However, with 30 bins unseen test datas also have a little higher accuracy (59.5%) compared to 59.13% of 45 bins. \n",
    "\n",
    "Therefore, I will conclude that with random forest classifier the maximum accuracy can be achieved by selecting  30 bins of (sin(theta))^2 and 30 DST coefficients. The model has OOB score of 58.87% and validation accuracy with unseen data is 59.5% .\n",
    "\n",
    "So, the final model is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "rf1_30_30=RandomForestClassifier(oob_score=True, random_state=0,n_estimators=1000,criterion=\"entropy\",ccp_alpha=1e-10, max_features='sqrt', min_samples_leaf=1, min_samples_split=2, n_jobs=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.0, 0.5951697752271641, 0.5887011054421769)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rf1_30_30.fit(x_train_scaled_30_30, y_train_30_30)\n",
    "y_pred_train_rf1_30_30 = rf1_30_30.predict(x_train_scaled_30_30)\n",
    "y_pred_test_rf1_30_30 = rf1_30_30.predict(x_test_scaled_30_30)\n",
    "accuracy_train_rf=(y_train_30_30 == y_pred_train_rf1_30_30).sum()/x_train_scaled_30_30.shape[0]\n",
    "accuracy_test_rf=(y_test_30_30 == y_pred_test_rf1_30_30).sum()/x_test_scaled_30_30.shape[0]\n",
    "# Accuracies\n",
    "accuracy_train_rf, accuracy_test_rf, rf1_30_30.oob_score_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Raihan\\Anaconda3\\envs\\nano281\\lib\\site-packages\\seaborn\\_decorators.py:43: FutureWarning: Pass the following variables as keyword args: x, y. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n",
      "  FutureWarning\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x1152 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplots(figsize=(16, 16))\n",
    "sns.barplot(rf1_30_30.feature_importances_, list(final_feature_training_30_30.columns), orient='h')\n",
    "plt.xlabel(\"Feature importance\");"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "def get_cm(y, y_pred):\n",
    "    train_cm = confusion_matrix(y, y_pred)\n",
    "\n",
    "    column_labels = ['class_%d'%i for i in range(1, 15)]\n",
    "\n",
    "    return pd.DataFrame(train_cm, columns=['pred_'+i for i in column_labels], \n",
    "                              index=['true_' + i for i in column_labels])\n",
    "\n",
    "#train_cm_df = get_cm(y_train, y_pred_train_random_for3)\n",
    "test_cm_df = get_cm(y_test_30_30,y_pred_test_rf1_30_30)\n",
    "#print('Train data', train_cm_df)\n",
    "TP=[test_cm_df.iloc[i,i] for i in range(14)]\n",
    "TN=np.array(test_cm_df.sum(axis=1))-TP\n",
    "FP=np.array(test_cm_df.sum())-TP\n",
    "#test_cm_df\n",
    "#print('Test data', test_cm_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>pred_class_1</th>\n",
       "      <th>pred_class_2</th>\n",
       "      <th>pred_class_3</th>\n",
       "      <th>pred_class_4</th>\n",
       "      <th>pred_class_5</th>\n",
       "      <th>pred_class_6</th>\n",
       "      <th>pred_class_7</th>\n",
       "      <th>pred_class_8</th>\n",
       "      <th>pred_class_9</th>\n",
       "      <th>pred_class_10</th>\n",
       "      <th>pred_class_11</th>\n",
       "      <th>pred_class_12</th>\n",
       "      <th>pred_class_13</th>\n",
       "      <th>pred_class_14</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>true_class_1</th>\n",
       "      <td>243</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>4</td>\n",
       "      <td>74</td>\n",
       "      <td>31</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>26</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>true_class_2</th>\n",
       "      <td>0</td>\n",
       "      <td>377</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>true_class_3</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>95</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>true_class_4</th>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>176</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>9</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>true_class_5</th>\n",
       "      <td>9</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>306</td>\n",
       "      <td>27</td>\n",
       "      <td>2</td>\n",
       "      <td>12</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>6</td>\n",
       "      <td>7</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>true_class_6</th>\n",
       "      <td>23</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>25</td>\n",
       "      <td>267</td>\n",
       "      <td>16</td>\n",
       "      <td>43</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>9</td>\n",
       "      <td>5</td>\n",
       "      <td>11</td>\n",
       "      <td>7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>true_class_7</th>\n",
       "      <td>102</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "      <td>148</td>\n",
       "      <td>51</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>67</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>true_class_8</th>\n",
       "      <td>42</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "      <td>20</td>\n",
       "      <td>68</td>\n",
       "      <td>168</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>37</td>\n",
       "      <td>17</td>\n",
       "      <td>5</td>\n",
       "      <td>8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>true_class_9</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "      <td>5</td>\n",
       "      <td>11</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>8</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>true_class_10</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>10</td>\n",
       "      <td>12</td>\n",
       "      <td>3</td>\n",
       "      <td>12</td>\n",
       "      <td>0</td>\n",
       "      <td>39</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>6</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>true_class_11</th>\n",
       "      <td>47</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>7</td>\n",
       "      <td>13</td>\n",
       "      <td>113</td>\n",
       "      <td>89</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>128</td>\n",
       "      <td>18</td>\n",
       "      <td>7</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>true_class_12</th>\n",
       "      <td>16</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>22</td>\n",
       "      <td>15</td>\n",
       "      <td>7</td>\n",
       "      <td>42</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>14</td>\n",
       "      <td>104</td>\n",
       "      <td>15</td>\n",
       "      <td>10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>true_class_13</th>\n",
       "      <td>6</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>19</td>\n",
       "      <td>28</td>\n",
       "      <td>1</td>\n",
       "      <td>17</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>8</td>\n",
       "      <td>5</td>\n",
       "      <td>229</td>\n",
       "      <td>13</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>true_class_14</th>\n",
       "      <td>32</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>11</td>\n",
       "      <td>16</td>\n",
       "      <td>22</td>\n",
       "      <td>18</td>\n",
       "      <td>39</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>26</td>\n",
       "      <td>9</td>\n",
       "      <td>15</td>\n",
       "      <td>198</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               pred_class_1  pred_class_2  pred_class_3  pred_class_4  \\\n",
       "true_class_1            243             0             1             0   \n",
       "true_class_2              0           377             1             1   \n",
       "true_class_3              0             0            95             2   \n",
       "true_class_4              2             0             0           176   \n",
       "true_class_5              9             1             1             4   \n",
       "true_class_6             23             6             0             4   \n",
       "true_class_7            102             0             0             0   \n",
       "true_class_8             42             1             0             4   \n",
       "true_class_9              0             1             0             0   \n",
       "true_class_10             3             1             1             1   \n",
       "true_class_11            47             0             1             4   \n",
       "true_class_12            16             0             1             1   \n",
       "true_class_13             6             3             1             2   \n",
       "true_class_14            32             0             0            11   \n",
       "\n",
       "               pred_class_5  pred_class_6  pred_class_7  pred_class_8  \\\n",
       "true_class_1              4             4            74            31   \n",
       "true_class_2              2             2             0             1   \n",
       "true_class_3              2             5             1             2   \n",
       "true_class_4              1             4             1             9   \n",
       "true_class_5            306            27             2            12   \n",
       "true_class_6             25           267            16            43   \n",
       "true_class_7              2             3           148            51   \n",
       "true_class_8              7            20            68           168   \n",
       "true_class_9              3             6             0             5   \n",
       "true_class_10            10            12             3            12   \n",
       "true_class_11             7            13           113            89   \n",
       "true_class_12            22            15             7            42   \n",
       "true_class_13            19            28             1            17   \n",
       "true_class_14            16            22            18            39   \n",
       "\n",
       "               pred_class_9  pred_class_10  pred_class_11  pred_class_12  \\\n",
       "true_class_1              0              0             26              2   \n",
       "true_class_2              0              1              0              0   \n",
       "true_class_3              0              0              0              0   \n",
       "true_class_4              0              0              1              4   \n",
       "true_class_5              0              0              1              6   \n",
       "true_class_6              0              0              9              5   \n",
       "true_class_7              0              0             67              3   \n",
       "true_class_8              0              1             37             17   \n",
       "true_class_9             11              0              1              2   \n",
       "true_class_10             0             39              5              5   \n",
       "true_class_11             0              2            128             18   \n",
       "true_class_12             0              0             14            104   \n",
       "true_class_13             1              0              8              5   \n",
       "true_class_14             0              0             26              9   \n",
       "\n",
       "               pred_class_13  pred_class_14  \n",
       "true_class_1               0              2  \n",
       "true_class_2               0              0  \n",
       "true_class_3               2              2  \n",
       "true_class_4               0              5  \n",
       "true_class_5               7              2  \n",
       "true_class_6              11              7  \n",
       "true_class_7               0              4  \n",
       "true_class_8               5              8  \n",
       "true_class_9               8              0  \n",
       "true_class_10              6              1  \n",
       "true_class_11              7             13  \n",
       "true_class_12             15             10  \n",
       "true_class_13            229             13  \n",
       "true_class_14             15            198  "
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test_cm_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the above plot, we can easily understand the importance of different features. I calculated ration of (sin(theta))^2 using the a=[(sin(theta))^2 at the first peak]. According to the graph, the most important features are,\n",
    "\n",
    "(1) Standard  deviation of the (sin(theta))^2/a values at the peaks. How the peak planes are spreaded\n",
    "\n",
    "(2) (sin(theta))^2/a for the 2nd peak. This value can easily identify symmetric crystal. For example, for cP it should be just 2 \n",
    "\n",
    "(3) Ration of total peaks to (sin(theta))^2/a. This value also gives the information of symmetry.\n",
    "\n",
    "(4) Maximum value of (sin(theta))^2/a. The higher the value the more allowable values for peak diffraction (information of symmetry)\n",
    "\n",
    "(5) (6) (7) 2nd, 3rd and 4th coefficient of DST transform. In other words, it takes information of the dominant peaks along with the full spectrum\n",
    "\n",
    "(8) (9) Meand and standard deviation of the peak heights are also important. However, their contribution to the determination of the crystal structure is not that high as like the sine of the peak angles. The model also shows that."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Light GBM Classifier (Gradient Boost Classifier)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Since for random forest classifier, I have already optimized the features, I will use that feature to optimize this light gbm classifier. Also since n_estimators=1000 gives the best result for random forest classifier, I will use the same n_estimators for this model. Similarly min_samples_leaf (equivalent to min_child_samples in LGBM) of 1 and min_samples_split of 2 give the best result for Random Forest Classifier model, therefore I will use those same parameters for these model too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "from lightgbm import LGBMClassifier\n",
    "lightgbm_model = LGBMClassifier(random_state=0,n_estimators=1000, reg_alpha='1', lambda_l2='1', min_child_samples=1, min_samples_split=2, n_jobs=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LightGBM] [Warning] Unknown parameter: min_samples_split\n",
      "[LightGBM] [Warning] lambda_l2 is set=1, reg_lambda=0.0 will be ignored. Current value: lambda_l2=1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.9999734268707483, 0.599713055954089]"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lightgbm_model.fit(x_train_scaled_30_30, y_train_30_30)\n",
    "y_pred_train_lgbm_30_30 = lightgbm_model.predict(x_train_scaled_30_30)\n",
    "y_pred_test_lgbm_30_30 = lightgbm_model.predict(x_test_scaled_30_30)\n",
    "[(y_train_30_30 == y_pred_train_lgbm_30_30).sum()/x_train_scaled_30_30.shape[0], (y_test_30_30 == y_pred_test_lgbm_30_30).sum()/x_test_scaled_30_30.shape[0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.9999734268707483, 0.599713055954089)"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_train_lgbm_30_30=(y_train_30_30 == y_pred_train_lgbm_30_30).sum()/x_train_scaled_30_30.shape[0]\n",
    "accuracy_test_lgbm_30_30=(y_test_30_30 == y_pred_test_lgbm_30_30).sum()/x_test_scaled_30_30.shape[0]\n",
    "accuracy_train_lgbm_30_30, accuracy_test_lgbm_30_30"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As it can be seen with the light gbm model the accuracy is 59.97% for the unseen data whereas for the random forest classifier model it was 59.5%. Therefore, by far this is the best model.\n",
    "\n",
    "In order to optimize the parameters, I will vary reg_alpha and lambda_l2 and check the accuracy on the test data to optimize the mdoel since test data is unseen to the model and therefore it is fair to judge the model based on this performance. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LightGBM] [Warning] Unknown parameter: min_samples_split\n",
      "[LightGBM] [Warning] lambda_l2 is set=0, reg_lambda=0.0 will be ignored. Current value: lambda_l2=0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.5915829746532759"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Decreasing lambda_l2\n",
    "light1=LGBMClassifier(random_state=0,n_estimators=1000, reg_alpha='1', lambda_l2='0', min_child_samples=1, min_samples_split=2, n_jobs=-1)\n",
    "light1.fit(x_train_scaled_30_30, y_train_30_30)\n",
    "y_pred_train_lgbm_30_30 = light1.predict(x_train_scaled_30_30)\n",
    "y_pred_test_lgbm_30_30 = light1.predict(x_test_scaled_30_30)\n",
    "(y_test_30_30 == y_pred_test_lgbm_30_30).sum()/x_test_scaled_30_30.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LightGBM] [Warning] Unknown parameter: min_samples_split\n",
      "[LightGBM] [Warning] lambda_l2 is set=0.5, reg_lambda=0.0 will be ignored. Current value: lambda_l2=0.5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.59636537541846"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Decreasing lambda_l2\n",
    "light1=LGBMClassifier(random_state=0,n_estimators=1000, reg_alpha='1', lambda_l2='0.5', min_child_samples=1, min_samples_split=2, n_jobs=-1)\n",
    "light1.fit(x_train_scaled_30_30, y_train_30_30)\n",
    "y_pred_train_lgbm_30_30 = light1.predict(x_train_scaled_30_30)\n",
    "y_pred_test_lgbm_30_30 = light1.predict(x_test_scaled_30_30)\n",
    "(y_test_30_30 == y_pred_test_lgbm_30_30).sum()/x_test_scaled_30_30.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LightGBM] [Warning] Unknown parameter: min_samples_split\n",
      "[LightGBM] [Warning] lambda_l2 is set=1, reg_lambda=0.0 will be ignored. Current value: lambda_l2=1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.6068866571018652"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Decreasing reg_alpha\n",
    "light1=LGBMClassifier(random_state=0,n_estimators=1000, reg_alpha='0', lambda_l2='1', min_child_samples=1, min_samples_split=2, n_jobs=-1)\n",
    "light1.fit(x_train_scaled_30_30, y_train_30_30)\n",
    "y_pred_train_lgbm_30_30 = light1.predict(x_train_scaled_30_30)\n",
    "y_pred_test_lgbm_30_30 = light1.predict(x_test_scaled_30_30)\n",
    "(y_test_30_30 == y_pred_test_lgbm_30_30).sum()/x_test_scaled_30_30.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LightGBM] [Warning] Unknown parameter: min_samples_split\n",
      "[LightGBM] [Warning] lambda_l2 is set=1, reg_lambda=0.0 will be ignored. Current value: lambda_l2=1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.6035389765662362"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Decreasing reg_alpha\n",
    "light1=LGBMClassifier(random_state=0,n_estimators=1000, reg_alpha='0.5', lambda_l2='1', min_child_samples=1, min_samples_split=2, n_jobs=-1)\n",
    "light1.fit(x_train_scaled_30_30, y_train_30_30)\n",
    "y_pred_train_lgbm_30_30 = light1.predict(x_train_scaled_30_30)\n",
    "y_pred_test_lgbm_30_30 = light1.predict(x_test_scaled_30_30)\n",
    "(y_test_30_30 == y_pred_test_lgbm_30_30).sum()/x_test_scaled_30_30.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LightGBM] [Warning] Unknown parameter: min_samples_split\n",
      "[LightGBM] [Warning] lambda_l2 is set=2, reg_lambda=0.0 will be ignored. Current value: lambda_l2=2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.6016260162601627"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Increasing lambda_l2\n",
    "light1=LGBMClassifier(random_state=0,n_estimators=1000, reg_alpha='1', lambda_l2='2', min_child_samples=1, min_samples_split=2, n_jobs=-1)\n",
    "light1.fit(x_train_scaled_30_30, y_train_30_30)\n",
    "y_pred_train_lgbm_30_30 = light1.predict(x_train_scaled_30_30)\n",
    "y_pred_test_lgbm_30_30 = light1.predict(x_test_scaled_30_30)\n",
    "(y_test_30_30 == y_pred_test_lgbm_30_30).sum()/x_test_scaled_30_30.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LightGBM] [Warning] Unknown parameter: min_samples_split\n",
      "[LightGBM] [Warning] lambda_l2 is set=1, reg_lambda=0.0 will be ignored. Current value: lambda_l2=1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.5982783357245337"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Increasing reg_alpha\n",
    "light1=LGBMClassifier(random_state=0,n_estimators=1000, reg_alpha='2', lambda_l2='1', min_child_samples=1, min_samples_split=2, n_jobs=-1)\n",
    "light1.fit(x_train_scaled_30_30, y_train_30_30)\n",
    "y_pred_train_lgbm_30_30 = light1.predict(x_train_scaled_30_30)\n",
    "y_pred_test_lgbm_30_30 = light1.predict(x_test_scaled_30_30)\n",
    "(y_test_30_30 == y_pred_test_lgbm_30_30).sum()/x_test_scaled_30_30.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the model accuracy scores for different lambda_l2 and reg_alpha, it can be easily seen that, the highest accuracy can be obtained for reg_alpha=0 and lambda_l2=1. Therefore these parameters are chosen for the final model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[LightGBM] [Warning] Unknown parameter: min_samples_split\n",
      "[LightGBM] [Warning] lambda_l2 is set=1, reg_lambda=0.0 will be ignored. Current value: lambda_l2=1\n"
     ]
    }
   ],
   "source": [
    "light_final=LGBMClassifier(random_state=0,n_estimators=1000, reg_alpha='0', lambda_l2='1', min_child_samples=1, min_samples_split=2, n_jobs=-1)\n",
    "light_final.fit(x_train_scaled_30_30, y_train_30_30)\n",
    "y_pred_train_lgbm_30_30 = light_final.predict(x_train_scaled_30_30)\n",
    "y_pred_test_lgbm_30_30 = light_final.predict(x_test_scaled_30_30)\n",
    "accuracy_test_lgbm=(y_test_30_30 == y_pred_test_lgbm_30_30).sum()/x_test_scaled_30_30.shape[0]\n",
    "accuracy_train_lgbm=(y_train_30_30 == y_pred_train_lgbm_30_30).sum()/x_train_scaled_30_30.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6068866571018652"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_test_lgbm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The accuracy of the light gbm classifier (gradient boost classifier) is 60.69%"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Finding accuracy of GaussianNB and KNN with 30_30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.296987087517934"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Gaussian NB\n",
    "gnb = GaussianNB()\n",
    "gnb.fit(x_train_scaled_30_30, y_train_30_30)\n",
    "y_pred_test_gnb = gnb.predict(x_test_scaled_30_30)\n",
    "accuracy_test_gnb=(y_test_30_30 == y_pred_test_gnb).sum()/x_test_scaled_30_30.shape[0]\n",
    "accuracy_test_gnb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4815877570540411"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# KNN\n",
    "knn = KNeighborsClassifier(n_jobs=-1,p=1,n_neighbors=5)\n",
    "knn.fit(x_train_scaled_30_30, y_train_30_30)\n",
    "y_pred_test_knn = knn.predict(x_test_scaled_30_30)\n",
    "accuracy_test_knn=(y_test_30_30 == y_pred_test_knn).sum()/x_test_scaled_30_30.shape[0]\n",
    "accuracy_test_knn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The accuracy of different models:\n",
    "\n",
    "GaussianNB: 29.69%\n",
    "\n",
    "KNN: 48.158%\n",
    "\n",
    "Random Forest Classifier: 59.52%\n",
    "\n",
    "Light GBM Classifier:60.69%"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "nbin_sin2theta=30;start_bin=1;end_bin=11;dst_coeff=30;\n",
    "base_feature_kaggle,final_feature_kaggle_45_20=calculate_features(kaggle_data_filepath,nbin_sin2theta,start_bin,end_bin,dst_coeff)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "minmax_scaler_30_30=minmax_scaler\n",
    "minmax_scaler_30_30.fit(x_train_30_30)\n",
    "testtt=minmax_scaler_30_30.transform(final_feature_kaggle_45_20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred_test_lgbm_30_30k = light_final.predict(testtt)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_filepath_test=\"C:\\\\Users\\\\Raihan\\\\Nano281_project\\\\test.csv\"\n",
    "testt_data=pd.read_csv(data_filepath_test,na_filter=False)\n",
    "\n",
    "test_predicted_data_lgbm_45=pd.DataFrame(testt_data['id'],columns=['id'])\n",
    "test_predicted_data_lgbm_45['bravais_lattice']=le.inverse_transform(y_pred_test_lgbm_30_30k)\n",
    "test_data_out_lgbm_45_filepath=\"C:\\\\Users\\\\Raihan\\\\Nano281_project\\\\test_out_v10.csv\"\n",
    "test_predicted_data_lgbm_45.to_csv(test_data_out_lgbm_45_filepath,index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Saving Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "with open('Mohammad Abu_Raihan Miah_random_forest_classifier.pkl',\"wb\") as f:\n",
    "    pickle.dump(rf1_30_30, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "with open('Mohammad Abu_Raihan Miah_light_gbm.pkl',\"wb\") as f:\n",
    "    pickle.dump(lightgbm_model, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('Mohammad Abu_Raihan Miah_random_forest_classifier2.pkl',\"wb\") as f:\n",
    "    pickle.dump(rf1_45, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('Mohammad Abu_Raihan Miah_knn.pkl',\"wb\") as f:\n",
    "    pickle.dump(knn, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('Mohammad Abu_Raihan Miah_light_gbm2.pkl',\"wb\") as f:\n",
    "    pickle.dump(light_final, f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}