f5c_signal_classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"/projects/ly_vu_direct_rna/MetaCompore/results/xpore/xpore_eventalign/MYC/cnot3_test_0_data_MYC.tsv\",sep=\"\\t\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.columns = [\"contig\",\"position\",\"reference_kmer\",\"read_index\",\"strand\",\"event_index\",\"event_level_mean\",\"event_stdv\",\"event_length\",\"model_kmer\",\"model_mean\",\"model_stdv\",\"standardized_level\",\"start_idx\",\"end_idx\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "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>contig</th>\n",
       "      <th>position</th>\n",
       "      <th>reference_kmer</th>\n",
       "      <th>read_index</th>\n",
       "      <th>strand</th>\n",
       "      <th>event_index</th>\n",
       "      <th>event_level_mean</th>\n",
       "      <th>event_stdv</th>\n",
       "      <th>event_length</th>\n",
       "      <th>model_kmer</th>\n",
       "      <th>model_mean</th>\n",
       "      <th>model_stdv</th>\n",
       "      <th>standardized_level</th>\n",
       "      <th>start_idx</th>\n",
       "      <th>end_idx</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>ENST00000377970.6</td>\n",
       "      <td>0</td>\n",
       "      <td>CTGCT</td>\n",
       "      <td>664445</td>\n",
       "      <td>t</td>\n",
       "      <td>10</td>\n",
       "      <td>98.27</td>\n",
       "      <td>1.969</td>\n",
       "      <td>0.00233</td>\n",
       "      <td>CTGCT</td>\n",
       "      <td>96.87</td>\n",
       "      <td>3.13</td>\n",
       "      <td>0.38</td>\n",
       "      <td>104237</td>\n",
       "      <td>104244</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>ENST00000377970.6</td>\n",
       "      <td>1</td>\n",
       "      <td>TGCTC</td>\n",
       "      <td>664445</td>\n",
       "      <td>t</td>\n",
       "      <td>11</td>\n",
       "      <td>109.60</td>\n",
       "      <td>5.097</td>\n",
       "      <td>0.00467</td>\n",
       "      <td>TGCTC</td>\n",
       "      <td>108.76</td>\n",
       "      <td>3.55</td>\n",
       "      <td>0.20</td>\n",
       "      <td>104223</td>\n",
       "      <td>104237</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>ENST00000377970.6</td>\n",
       "      <td>2</td>\n",
       "      <td>GCTCG</td>\n",
       "      <td>664445</td>\n",
       "      <td>t</td>\n",
       "      <td>12</td>\n",
       "      <td>79.01</td>\n",
       "      <td>1.978</td>\n",
       "      <td>0.00333</td>\n",
       "      <td>GCTCG</td>\n",
       "      <td>78.06</td>\n",
       "      <td>2.85</td>\n",
       "      <td>0.28</td>\n",
       "      <td>104213</td>\n",
       "      <td>104223</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>ENST00000377970.6</td>\n",
       "      <td>2</td>\n",
       "      <td>GCTCG</td>\n",
       "      <td>664445</td>\n",
       "      <td>t</td>\n",
       "      <td>13</td>\n",
       "      <td>80.79</td>\n",
       "      <td>2.180</td>\n",
       "      <td>0.00433</td>\n",
       "      <td>GCTCG</td>\n",
       "      <td>78.06</td>\n",
       "      <td>2.85</td>\n",
       "      <td>0.81</td>\n",
       "      <td>104200</td>\n",
       "      <td>104213</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>ENST00000377970.6</td>\n",
       "      <td>2</td>\n",
       "      <td>GCTCG</td>\n",
       "      <td>664445</td>\n",
       "      <td>t</td>\n",
       "      <td>14</td>\n",
       "      <td>77.04</td>\n",
       "      <td>1.740</td>\n",
       "      <td>0.00867</td>\n",
       "      <td>GCTCG</td>\n",
       "      <td>78.06</td>\n",
       "      <td>2.85</td>\n",
       "      <td>-0.30</td>\n",
       "      <td>104174</td>\n",
       "      <td>104200</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              contig  position reference_kmer  read_index strand  event_index  \\\n",
       "0  ENST00000377970.6         0          CTGCT      664445      t           10   \n",
       "1  ENST00000377970.6         1          TGCTC      664445      t           11   \n",
       "2  ENST00000377970.6         2          GCTCG      664445      t           12   \n",
       "3  ENST00000377970.6         2          GCTCG      664445      t           13   \n",
       "4  ENST00000377970.6         2          GCTCG      664445      t           14   \n",
       "\n",
       "   event_level_mean  event_stdv  event_length model_kmer  model_mean  \\\n",
       "0             98.27       1.969       0.00233      CTGCT       96.87   \n",
       "1            109.60       5.097       0.00467      TGCTC      108.76   \n",
       "2             79.01       1.978       0.00333      GCTCG       78.06   \n",
       "3             80.79       2.180       0.00433      GCTCG       78.06   \n",
       "4             77.04       1.740       0.00867      GCTCG       78.06   \n",
       "\n",
       "   model_stdv  standardized_level  start_idx  end_idx  \n",
       "0        3.13                0.38     104237   104244  \n",
       "1        3.55                0.20     104223   104237  \n",
       "2        2.85                0.28     104213   104223  \n",
       "3        2.85                0.81     104200   104213  \n",
       "4        2.85               -0.30     104174   104200  "
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "            position     read_index    event_index  event_level_mean  \\\n",
      "count  691579.000000  691579.000000  691579.000000     691579.000000   \n",
      "mean     1121.928955  664513.623207    2701.849442         95.344854   \n",
      "std       672.700077      39.851666    1611.656332         17.517032   \n",
      "min         0.000000  664445.000000       1.000000         48.320000   \n",
      "25%       531.000000  664479.000000    1355.000000         80.610000   \n",
      "50%      1103.000000  664513.000000    2650.000000         93.030000   \n",
      "75%      1696.000000  664548.000000    3941.000000        109.210000   \n",
      "max      2346.000000  664587.000000    9407.000000        151.400000   \n",
      "\n",
      "          event_stdv   event_length     model_mean     model_stdv  \\\n",
      "count  691579.000000  691579.000000  691579.000000  691579.000000   \n",
      "mean        3.654939       0.007056      93.756895       3.620649   \n",
      "std         2.749940       0.005833      20.299477       1.596048   \n",
      "min         0.000000       0.001670       0.000000       0.000000   \n",
      "25%         1.776000       0.003000      80.100000       2.600000   \n",
      "50%         2.734000       0.005000      92.590000       3.170000   \n",
      "75%         4.590000       0.009000     109.320000       4.490000   \n",
      "max        28.824000       0.132000     136.890000       9.690000   \n",
      "\n",
      "       standardized_level      start_idx        end_idx  \n",
      "count           691579.00  691579.000000  691579.000000  \n",
      "mean                  inf   67667.326142   67688.495835  \n",
      "std                   NaN   34905.811105   34905.976432  \n",
      "min                -14.15    3565.000000    3581.000000  \n",
      "25%                 -0.61   38759.000000   38778.000000  \n",
      "50%                  0.09   65970.000000   65990.000000  \n",
      "75%                  0.79   93128.500000   93151.000000  \n",
      "max                   inf  216576.000000  216583.000000  \n"
     ]
    }
   ],
   "source": [
    "print(df.describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[ df['event_level_mean'] <= 80.100000, 'event_level_mean'] = 0\n",
    "df.loc[(df['event_level_mean'] > 80.100000) & (df['event_level_mean'] <= 92.590000), 'event_level_mean'] = 1\n",
    "df.loc[(df['event_level_mean'] > 92.590000) & (df['event_level_mean'] <= 109.320000), 'event_level_mean']   = 2\n",
    "df.loc[ df['event_level_mean'] > 109.320000, 'event_level_mean'] = 3\n",
    "df['event_level_mean'] = df['event_level_mean'].astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = df.event_level_mean.values\n",
    "x_data = df.drop(['event_level_mean',\"contig\",\"read_index\",\"strand\",\"event_index\",\"event_stdv\",\"model_kmer\",\"model_stdv\",\"standardized_level\",\"start_idx\",\"end_idx\"], axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/projects/ly_vu_direct_rna/pipeline-polya-diff/.snakemake/conda/b03f8a95a14cdc0ca0aa7496df1e519e/lib/python3.11/site-packages/numpy/core/fromnumeric.py:84: FutureWarning: In a future version, DataFrame.min(axis=None) will return a scalar min over the entire DataFrame. To retain the old behavior, use 'frame.min(axis=0)' or just 'frame.min()'\n",
      "  return reduction(axis=axis, out=out, **passkwargs)\n",
      "/projects/ly_vu_direct_rna/pipeline-polya-diff/.snakemake/conda/b03f8a95a14cdc0ca0aa7496df1e519e/lib/python3.11/site-packages/numpy/core/fromnumeric.py:84: FutureWarning: In a future version, DataFrame.max(axis=None) will return a scalar max over the entire DataFrame. To retain the old behavior, use 'frame.max(axis=0)' or just 'frame.max()'\n",
      "  return reduction(axis=axis, out=out, **passkwargs)\n",
      "/projects/ly_vu_direct_rna/pipeline-polya-diff/.snakemake/conda/b03f8a95a14cdc0ca0aa7496df1e519e/lib/python3.11/site-packages/numpy/core/fromnumeric.py:84: FutureWarning: In a future version, DataFrame.min(axis=None) will return a scalar min over the entire DataFrame. To retain the old behavior, use 'frame.min(axis=0)' or just 'frame.min()'\n",
      "  return reduction(axis=axis, out=out, **passkwargs)\n"
     ]
    }
   ],
   "source": [
    "# Normalize\n",
    "x_data['reference_kmer'] = pd.factorize(x_data['reference_kmer'])[0]\n",
    "x = (x_data - np.min(x_data)) / (np.max(x_data) - np.min(x_data)).values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 80% of our data will be train data and 20% of it will be test data\n",
    "x_train, x_test, y_train, y_test = train_test_split(x,y,test_size = 0.2,random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "#transpose matrices\n",
    "x_train = x_train.T\n",
    "y_train = y_train.T\n",
    "x_test = x_test.T\n",
    "y_test = y_test.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# weight = 0.01 and bias = 0.0\n",
    "#initialize\n",
    "def initialize(dimension):\n",
    "    \n",
    "    weight = np.full((dimension,1),0.01)\n",
    "    bias = 0.0\n",
    "    return weight,bias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigmoid(z):\n",
    "    \n",
    "    y_head = 1/(1+ np.exp(-z))\n",
    "    return y_head"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "def forwardBackward(weight,bias,x_train,y_train):\n",
    "    # Forward\n",
    "    \n",
    "    y_head = sigmoid(np.dot(weight.T,x_train) + bias)\n",
    "    loss = -(y_train*np.log(y_head) + (1-y_train)*np.log(1-y_head))\n",
    "    cost = np.sum(loss) / x_train.shape[1]\n",
    "    \n",
    "    # Backward\n",
    "    derivative_weight = np.dot(x_train,((y_head-y_train).T))/x_train.shape[1]\n",
    "    derivative_bias = np.sum(y_head-y_train)/x_train.shape[1]\n",
    "    gradients = {\"Derivative Weight\" : derivative_weight, \"Derivative Bias\" : derivative_bias}\n",
    "    \n",
    "    return cost,gradients"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update(weight,bias,x_train,y_train,learningRate,iteration) :\n",
    "    costList = []\n",
    "    index = []\n",
    "    \n",
    "    #for each iteration, update weight and bias values\n",
    "    for i in range(iteration):\n",
    "        cost,gradients = forwardBackward(weight,bias,x_train,y_train)\n",
    "        weight = weight - learningRate * gradients[\"Derivative Weight\"]\n",
    "        bias = bias - learningRate * gradients[\"Derivative Bias\"]\n",
    "        \n",
    "        costList.append(cost)\n",
    "        index.append(i)\n",
    "\n",
    "    parameters = {\"weight\": weight,\"bias\": bias}\n",
    "    \n",
    "    print(\"iteration:\",iteration)\n",
    "    print(\"cost:\",cost)\n",
    "\n",
    "    plt.plot(index,costList)\n",
    "    plt.xlabel(\"Number of Iteration\")\n",
    "    plt.ylabel(\"Cost\")\n",
    "    plt.show()\n",
    "\n",
    "    return parameters, gradients"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(weight,bias,x_test):\n",
    "    z = np.dot(weight.T,x_test) + bias\n",
    "    y_head = sigmoid(z)\n",
    "\n",
    "    y_prediction = np.zeros((1,x_test.shape[1]))\n",
    "    \n",
    "    for i in range(y_head.shape[1]):\n",
    "        if y_head[0,i] <= 0.5:\n",
    "            y_prediction[0,i] = 0\n",
    "        else:\n",
    "            y_prediction[0,i] = 1\n",
    "    return y_prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def logistic_regression(x_train,y_train,x_test,y_test,learningRate,iteration):\n",
    "    dimension = x_train.shape[0]\n",
    "    weight,bias = initialize(dimension)\n",
    "    \n",
    "    parameters, gradients = update(weight,bias,x_train,y_train,learningRate,iteration)\n",
    "\n",
    "    y_prediction = predict(parameters[\"weight\"],parameters[\"bias\"],x_test)\n",
    "    \n",
    "    print(\"Manuel Test Accuracy: {:.2f}%\".format((100 - np.mean(np.abs(y_prediction - y_test))*100)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "position          float64\n",
      "reference_kmer    float64\n",
      "event_length      float64\n",
      "model_mean        float64\n",
      "dtype: object\n"
     ]
    }
   ],
   "source": [
    "print(x.dtypes)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_128616/833209203.py:5: RuntimeWarning: divide by zero encountered in log\n",
      "  loss = -(y_train*np.log(y_head) + (1-y_train)*np.log(1-y_head))\n",
      "/tmp/ipykernel_128616/833209203.py:5: RuntimeWarning: invalid value encountered in multiply\n",
      "  loss = -(y_train*np.log(y_head) + (1-y_train)*np.log(1-y_head))\n",
      "/projects/ly_vu_direct_rna/pipeline-polya-diff/.snakemake/conda/b03f8a95a14cdc0ca0aa7496df1e519e/lib/python3.11/site-packages/numpy/core/fromnumeric.py:86: RuntimeWarning: invalid value encountered in reduce\n",
      "  return ufunc.reduce(obj, axis, dtype, out, **passkwargs)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iteration: 1000\n",
      "cost: nan\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Manuel Test Accuracy: 0.58%\n"
     ]
    }
   ],
   "source": [
    "logistic_regression(x_train,y_train,x_test,y_test,1,1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy 75.69%\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/projects/ly_vu_direct_rna/pipeline-polya-diff/.snakemake/conda/b03f8a95a14cdc0ca0aa7496df1e519e/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py:458: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
      "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
      "\n",
      "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
      "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
      "Please also refer to the documentation for alternative solver options:\n",
      "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
      "  n_iter_i = _check_optimize_result(\n"
     ]
    }
   ],
   "source": [
    "accuracies = {}\n",
    "\n",
    "lr = LogisticRegression()\n",
    "lr.fit(x_train.T,y_train.T)\n",
    "acc = lr.score(x_test.T,y_test.T)*100\n",
    "\n",
    "accuracies['Logistic Regression'] = acc\n",
    "print(\"Test Accuracy {:.2f}%\".format(acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Forest Algorithm Accuracy Score : 80.77%\n"
     ]
    }
   ],
   "source": [
    "# Random Forest Classification\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "rf = RandomForestClassifier(n_estimators = 1000, random_state = 1)\n",
    "rf.fit(x_train.T, y_train.T)\n",
    "\n",
    "acc = rf.score(x_test.T,y_test.T)*100\n",
    "accuracies['Random Forest'] = acc\n",
    "print(\"Random Forest Algorithm Accuracy Score : {:.2f}%\".format(acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 0 1 ... 1 1 0]\n"
     ]
    }
   ],
   "source": [
    "y_pred = rf.predict(x_test.T)\n",
    "print(y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 NN Score: 75.86%\n"
     ]
    }
   ],
   "source": [
    "# KNN Model\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "knn = KNeighborsClassifier(n_neighbors = 2)  # n_neighbors means k\n",
    "knn.fit(x_train.T, y_train.T)\n",
    "prediction = knn.predict(x_test.T)\n",
    "\n",
    "print(\"{} NN Score: {:.2f}%\".format(2, knn.score(x_test.T, y_test.T)*100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum KNN Score is 81.64%\n"
     ]
    }
   ],
   "source": [
    "# try ro find best k value\n",
    "scoreList = []\n",
    "for i in range(1,20):\n",
    "    knn2 = KNeighborsClassifier(n_neighbors = i)  # n_neighbors means k\n",
    "    knn2.fit(x_train.T, y_train.T)\n",
    "    scoreList.append(knn2.score(x_test.T, y_test.T))\n",
    "    \n",
    "plt.plot(range(1,20), scoreList)\n",
    "plt.xticks(np.arange(1,20,1))\n",
    "plt.xlabel(\"K value\")\n",
    "plt.ylabel(\"Score\")\n",
    "plt.show()\n",
    "\n",
    "acc = max(scoreList)*100\n",
    "accuracies['KNN'] = acc\n",
    "print(\"Maximum KNN Score is {:.2f}%\".format(acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy of SVM Algorithm: 79.27%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.svm import SVC\n",
    "svm = SVC(random_state = 1)\n",
    "svm.fit(x_train.T, y_train.T)\n",
    "\n",
    "acc = svm.score(x_test.T,y_test.T)*100\n",
    "accuracies['SVM'] = acc\n",
    "print(\"Test Accuracy of SVM Algorithm: {:.2f}%\".format(acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy of Naive Bayes: 73.21%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.naive_bayes import GaussianNB\n",
    "nb = GaussianNB()\n",
    "nb.fit(x_train.T, y_train.T)\n",
    "\n",
    "acc = nb.score(x_test.T,y_test.T)*100\n",
    "accuracies['Naive Bayes'] = acc\n",
    "print(\"Accuracy of Naive Bayes: {:.2f}%\".format(acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Decision Tree Test Accuracy 80.33%\n"
     ]
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "dtc = DecisionTreeClassifier()\n",
    "dtc.fit(x_train.T, y_train.T)\n",
    "\n",
    "acc = dtc.score(x_test.T, y_test.T)*100\n",
    "accuracies['Decision Tree'] = acc\n",
    "print(\"Decision Tree Test Accuracy {:.2f}%\".format(acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "colors = [\"purple\", \"green\", \"orange\", \"magenta\",\"#CFC60E\",\"#0FBBAE\"]\n",
    "\n",
    "sns.set_style(\"whitegrid\")\n",
    "plt.figure(figsize=(16,5))\n",
    "plt.yticks(np.arange(0,100,10))\n",
    "plt.ylabel(\"Accuracy %\")\n",
    "plt.xlabel(\"Algorithms\")\n",
    "sns.barplot(x=list(accuracies.keys()), y=list(accuracies.values()), palette=colors)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.2"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}