TrainingVsValidationErrorGraph.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import sklearn as sk\n",
    "from sklearn.model_selection import train_test_split\n",
    "eps=np.finfo(float).eps\n",
    "from binarytree import tree,Node\n",
    "from sklearn.metrics import classification_report, confusion_matrix ,accuracy_score\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from operator import itemgetter\n",
    "from pylab import *\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import copy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In[178]:\n",
    "df=pd.read_csv(\"train.csv\")\n",
    "node_count=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In[179]:\n",
    "\n",
    "\n",
    "X =df.drop(['left'],axis=1)\n",
    "# X = pd.concat([X,pd.get_dummies(df['sales'], prefix='sales')],axis=1)\n",
    "# X = pd.concat([X,pd.get_dummies(df['salary'], prefix='salary')],axis=1)\n",
    "y=df['left']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In[180]:\n",
    "\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n",
    "\n",
    "orignalX=copy.deepcopy(X_train)\n",
    "orignalY=copy.deepcopy(y_train)\n",
    "testX=copy.deepcopy(X_test)\n",
    "testY=copy.deepcopy(y_test)\n",
    "orignalX4=copy.deepcopy(X_train)\n",
    "orignalY4=copy.deepcopy(y_train)\n",
    "testX4=copy.deepcopy(X_test)\n",
    "testY4=copy.deepcopy(y_test)\n",
    "numeric=['last_evaluation','satisfaction_level','average_montly_hours','time_spend_company','number_project']\n",
    "\n",
    "\n",
    "# In[181]:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def findParentEntropy(df):\n",
    "    if df.empty==True:\n",
    "        return\n",
    "    classCol=df.keys()[-1]\n",
    "    #yeh sirf header return karega\n",
    "    resultValues=df[classCol].unique()\n",
    "    #all ouput values in output column\n",
    "    entropy=0\n",
    "    for value in resultValues:\n",
    "        fraction=df[classCol].value_counts()[value]/(len(df[classCol])+eps)\n",
    "        entropy+=-fraction*np.log2(fraction+eps)\n",
    "    return abs(entropy)\n",
    "    \n",
    "    \n",
    "\n",
    "\n",
    "# In[182]:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def findRelativeEntropy(df,attribute):\n",
    "    if df.empty==True:\n",
    "        return\n",
    "    classCol= df.keys()[-1] \n",
    "    #last col assumed as result \n",
    "    #getting target class \n",
    "    resultValues=df[classCol].unique() \n",
    "    attributeNames=df[attribute].unique()\n",
    "    entropy2 = 0\n",
    "    for attr in attributeNames:\n",
    "        entropy = 0\n",
    "        for value in resultValues:\n",
    "            #temp&hot with yes\n",
    "            num = len(df[attribute][df[attribute]==attr][df[classCol]==value])\n",
    "            #total hot\n",
    "            den = len(df[attribute][df[attribute]==attr])\n",
    "            fraction = num/(den+eps)\n",
    "            entropy += -fraction*np.log2(fraction+eps)\n",
    "        #entropy attribute/total*(entropy attribute_values)\n",
    "        fraction2 = den/len(df)  \n",
    "        entropy2 += -fraction2*entropy \n",
    "    return abs(entropy2)\n",
    "\n",
    "\n",
    "# In[183]:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_subtable(df, node,value):\n",
    "    return df[df[node] == value].reset_index(drop=True)\n",
    "\n",
    "\n",
    "# In[184]:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_subtableSmaller(df, node,value):\n",
    "    if df.empty==True:\n",
    "        return\n",
    "    return df[df[node] < value].reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In[185]:\n",
    "\n",
    "\n",
    "def get_subtableGreater(df, node,value):\n",
    "    if df.empty==True:\n",
    "        return\n",
    "    return df[df[node] >= value].reset_index(drop=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In[186]:\n",
    "\n",
    "def bestAttribute(df):\n",
    "    if df.empty==True:\n",
    "        return\n",
    "    infoGain={}\n",
    "    max2=0\n",
    "    attr=\"\"\n",
    "    entropy_1=findParentEntropy(df)\n",
    "    for key in df.keys()[:-1]:\n",
    "        \n",
    "        if key not in numeric:\n",
    "#             print(\"XXX-------\",key)\n",
    "            entropy_2=findRelativeEntropy(df,key)\n",
    "            if ((entropy_1-entropy_2)) > max2:\n",
    "                max2=entropy_1-entropy_2\n",
    "                attr=key\n",
    "    t=(max2,0)\n",
    "    infoGain[attr]=t\n",
    "    return infoGain\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In[187]:\n",
    "\n",
    "\n",
    "\n",
    "df=pd.concat([orignalX4,orignalY4],axis=1)\n",
    "def split(df):\n",
    "    \n",
    "    splitpoint={}\n",
    "    entropy1=findParentEntropy(df)\n",
    "    for col in numeric:\n",
    "        # df.sort_values(col,inplace=True)\n",
    "        prev=None;\n",
    "        value=0;\n",
    "        max1=0;\n",
    "#         print(col)\n",
    "        l=df[col].unique()\n",
    "        for mid in l:\n",
    "            # if prev is not None:\n",
    "    #             if prev['left'] != row['left']:\n",
    "            # mid=float(row[col])/2\n",
    "            subtableLeft=get_subtableSmaller(df,col,mid)\n",
    "            subtableRight=get_subtableGreater(df,col,mid)\n",
    "            fraction=len(subtableLeft)/len(df)\n",
    "            fraction1=len(subtableRight)/len(df)\n",
    "#                 print(subtableLeft)\n",
    "#                 a=input()\n",
    "            firstSubtable=0\n",
    "            secondSubtable=0\n",
    "            if subtableLeft.empty:\n",
    "                firstSubtable=0\n",
    "            else:\n",
    "                firstSubtable=fraction*findParentEntropy(subtableLeft)\n",
    "#                 print(subtableRight)\n",
    "            if subtableRight.empty:\n",
    "                secondSubtable=0\n",
    "            else:\n",
    "                secondSubtable=fraction1*findParentEntropy(subtableRight)\n",
    "\n",
    "            entropy2=firstSubtable+secondSubtable\n",
    "            ig1=abs(entropy1)-abs(entropy2)\n",
    "\n",
    "            if ig1>max1:\n",
    "                max1=ig1\n",
    "                value=mid\n",
    "        # prev=row\n",
    "        t=(max1,value)\n",
    "        splitpoint[col]=t\n",
    "    \n",
    "    return splitpoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "class node:\n",
    "    def __init__(self,value):\n",
    "        self.value=value\n",
    "        self.child=[]\n",
    "        self.edges=[]\n",
    "        self.positive=0\n",
    "        self.negative=0\n",
    "\n",
    "\n",
    "# In[190]:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "def buildTree(df,depth):\n",
    "    global node_count\n",
    "    resultLabel= df.keys()[-1] \n",
    "    clValue,counts = np.unique(df[resultLabel],return_counts=True)\n",
    "    \n",
    "    \n",
    "    if len(counts)<=1:\n",
    "        root=node(clValue[0])\n",
    "        node_count=node_count+1\n",
    "        if clValue[0]==0:\n",
    "            root.negative=counts[0]\n",
    "        else:\n",
    "            root.positive=counts[0]\n",
    "   \n",
    "    else:\n",
    "        if depth==0:\n",
    "            if counts[0]>counts[1]:\n",
    "                root=node(clValue[0])\n",
    "            else:\n",
    "                root=node(clValue[1])\n",
    "            node_count=node_count+1\n",
    "            return root\n",
    "        newsplit=split(df)\n",
    "        calsplit=bestAttribute(df)\n",
    "        newsplit.update(calsplit)\n",
    "        maxig=0\n",
    "        spoint=0\n",
    "        attr=\"\"\n",
    "        for k,t1 in newsplit.items():\n",
    "#             t1=i.value()\n",
    "            if maxig<t1[0]:\n",
    "                maxig=t1[0]\n",
    "                spoint=t1[1]\n",
    "                attr=k\n",
    "        root=node(attr)\n",
    "        node_count=node_count+1\n",
    "        root.split=spoint\n",
    "        root.positive=counts[1]\n",
    "        root.negative=counts[0]\n",
    "        \n",
    "        if attr in numeric:\n",
    "            subtable0 = get_subtableSmaller(df,attr,spoint)\n",
    "    #         subtable0 =subtable0.drop([attribute_name],axis=1)\n",
    "            subtable1 = get_subtableGreater(df,attr,spoint)\n",
    "            root.child.append(buildTree(subtable0,depth-1))\n",
    "            root.child.append(buildTree(subtable1,depth-1))\n",
    "            \n",
    "        else:\n",
    "            for j in df[attr].unique():\n",
    "                subtable0 = get_subtable(df,attr,j)\n",
    "                root.edges.append(j)\n",
    "                root.child.append(buildTree(subtable0,depth-1))\n",
    "\n",
    "       \n",
    "                   \n",
    "    return root"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In[191]:\n",
    "\n",
    "\n",
    "# print(df)\n",
    "# root=buildTree(df)\n",
    "# print(root.value)\n",
    "\n",
    "def testing(row1,root):\n",
    "    #     if root==None:\n",
    "    #         return \n",
    "        #print(root.value)\n",
    "        if len(root.child)==0:\n",
    "            y1.append(root.value)\n",
    "            return\n",
    "    #     for i in row1.keys():\n",
    "    #         if i==root.value:\n",
    "        i=root.value\n",
    "#         if i in row1:\n",
    "        if i in numeric:\n",
    "            if row1[i]<root.split:\n",
    "                testing(row1,root.child[0])\n",
    "            else:\n",
    "                testing(row1,root.child[1])\n",
    "        else:\n",
    "            k=0\n",
    "            #print(\"dd..\",i)\n",
    "            #print(\"sd...\",len(root.edges))\n",
    "            flag=0\n",
    "            for j in root.edges:\n",
    "                if row1[i]==j:\n",
    "#                     print(\"inside\")\n",
    "                    flag=1\n",
    "                    testing(row1,root.child[k])\n",
    "                    break\n",
    "                k=k+1\n",
    "            if flag==0:\n",
    "                if root.positive>root.negative:\n",
    "                    y1.append(1)\n",
    "                else:\n",
    "                    y1.append(0)\n",
    "                return\n",
    "                        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------Testing Data-------------------------------------------\n",
      "[[1463  259]\n",
      " [ 144  382]]\n",
      "0.8207295373665481\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.91      0.85      0.88      1722\n",
      "           1       0.60      0.73      0.65       526\n",
      "\n",
      "   micro avg       0.82      0.82      0.82      2248\n",
      "   macro avg       0.75      0.79      0.77      2248\n",
      "weighted avg       0.84      0.82      0.83      2248\n",
      "\n",
      "\n",
      "-----------------------------Training Data-----------------------------------------\n",
      "[[5863  978]\n",
      " [ 633 1516]]\n",
      "0.8208008898776418\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.90      0.86      0.88      6841\n",
      "           1       0.61      0.71      0.65      2149\n",
      "\n",
      "   micro avg       0.82      0.82      0.82      8990\n",
      "   macro avg       0.76      0.78      0.77      8990\n",
      "weighted avg       0.83      0.82      0.83      8990\n",
      "\n",
      "\n",
      "-------------------------Testing Data-------------------------------------------\n",
      "[[1633   89]\n",
      " [  33  493]]\n",
      "0.9457295373665481\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.95      0.96      1722\n",
      "           1       0.85      0.94      0.89       526\n",
      "\n",
      "   micro avg       0.95      0.95      0.95      2248\n",
      "   macro avg       0.91      0.94      0.93      2248\n",
      "weighted avg       0.95      0.95      0.95      2248\n",
      "\n",
      "\n",
      "-----------------------------Training Data-----------------------------------------\n",
      "[[6503  338]\n",
      " [ 167 1982]]\n",
      "0.9438264738598443\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.97      0.95      0.96      6841\n",
      "           1       0.85      0.92      0.89      2149\n",
      "\n",
      "   micro avg       0.94      0.94      0.94      8990\n",
      "   macro avg       0.91      0.94      0.92      8990\n",
      "weighted avg       0.95      0.94      0.94      8990\n",
      "\n",
      "\n",
      "-------------------------Testing Data-------------------------------------------\n",
      "[[1703   19]\n",
      " [  30  496]]\n",
      "0.978202846975089\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.99      0.99      1722\n",
      "           1       0.96      0.94      0.95       526\n",
      "\n",
      "   micro avg       0.98      0.98      0.98      2248\n",
      "   macro avg       0.97      0.97      0.97      2248\n",
      "weighted avg       0.98      0.98      0.98      2248\n",
      "\n",
      "\n",
      "-----------------------------Training Data-----------------------------------------\n",
      "[[6755   86]\n",
      " [ 159 1990]]\n",
      "0.9727474972191323\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.99      0.98      6841\n",
      "           1       0.96      0.93      0.94      2149\n",
      "\n",
      "   micro avg       0.97      0.97      0.97      8990\n",
      "   macro avg       0.97      0.96      0.96      8990\n",
      "weighted avg       0.97      0.97      0.97      8990\n",
      "\n",
      "\n",
      "-------------------------Testing Data-------------------------------------------\n",
      "[[1702   20]\n",
      " [  27  499]]\n",
      "0.9790925266903915\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.99      0.99      1722\n",
      "           1       0.96      0.95      0.96       526\n",
      "\n",
      "   micro avg       0.98      0.98      0.98      2248\n",
      "   macro avg       0.97      0.97      0.97      2248\n",
      "weighted avg       0.98      0.98      0.98      2248\n",
      "\n",
      "\n",
      "-----------------------------Training Data-----------------------------------------\n",
      "[[6803   38]\n",
      " [ 115 2034]]\n",
      "0.9829810901001113\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      0.99      0.99      6841\n",
      "           1       0.98      0.95      0.96      2149\n",
      "\n",
      "   micro avg       0.98      0.98      0.98      8990\n",
      "   macro avg       0.98      0.97      0.98      8990\n",
      "weighted avg       0.98      0.98      0.98      8990\n",
      "\n",
      "\n",
      "-------------------------Testing Data-------------------------------------------\n",
      "[[1698   24]\n",
      " [  19  507]]\n",
      "0.9808718861209964\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.99      0.99      1722\n",
      "           1       0.95      0.96      0.96       526\n",
      "\n",
      "   micro avg       0.98      0.98      0.98      2248\n",
      "   macro avg       0.97      0.97      0.97      2248\n",
      "weighted avg       0.98      0.98      0.98      2248\n",
      "\n",
      "\n",
      "-----------------------------Training Data-----------------------------------------\n",
      "[[6817   24]\n",
      " [  66 2083]]\n",
      "0.9899888765294772\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      1.00      0.99      6841\n",
      "           1       0.99      0.97      0.98      2149\n",
      "\n",
      "   micro avg       0.99      0.99      0.99      8990\n",
      "   macro avg       0.99      0.98      0.99      8990\n",
      "weighted avg       0.99      0.99      0.99      8990\n",
      "\n",
      "\n",
      "-------------------------Testing Data-------------------------------------------\n",
      "[[1696   26]\n",
      " [  16  510]]\n",
      "0.9813167259786477\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.98      0.99      1722\n",
      "           1       0.95      0.97      0.96       526\n",
      "\n",
      "   micro avg       0.98      0.98      0.98      2248\n",
      "   macro avg       0.97      0.98      0.97      2248\n",
      "weighted avg       0.98      0.98      0.98      2248\n",
      "\n",
      "\n",
      "-----------------------------Training Data-----------------------------------------\n",
      "[[6830   11]\n",
      " [  37 2112]]\n",
      "0.9946607341490545\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      1.00      1.00      6841\n",
      "           1       0.99      0.98      0.99      2149\n",
      "\n",
      "   micro avg       0.99      0.99      0.99      8990\n",
      "   macro avg       0.99      0.99      0.99      8990\n",
      "weighted avg       0.99      0.99      0.99      8990\n",
      "\n",
      "\n",
      "-------------------------Testing Data-------------------------------------------\n",
      "[[1686   36]\n",
      " [  13  513]]\n",
      "0.978202846975089\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.98      0.99      1722\n",
      "           1       0.93      0.98      0.95       526\n",
      "\n",
      "   micro avg       0.98      0.98      0.98      2248\n",
      "   macro avg       0.96      0.98      0.97      2248\n",
      "weighted avg       0.98      0.98      0.98      2248\n",
      "\n",
      "\n",
      "-----------------------------Training Data-----------------------------------------\n",
      "[[6835    6]\n",
      " [  14 2135]]\n",
      "0.9977753058954394\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00      6841\n",
      "           1       1.00      0.99      1.00      2149\n",
      "\n",
      "   micro avg       1.00      1.00      1.00      8990\n",
      "   macro avg       1.00      1.00      1.00      8990\n",
      "weighted avg       1.00      1.00      1.00      8990\n",
      "\n",
      "\n",
      "-------------------------Testing Data-------------------------------------------\n",
      "[[1687   35]\n",
      " [  12  514]]\n",
      "0.9790925266903915\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.98      0.99      1722\n",
      "           1       0.94      0.98      0.96       526\n",
      "\n",
      "   micro avg       0.98      0.98      0.98      2248\n",
      "   macro avg       0.96      0.98      0.97      2248\n",
      "weighted avg       0.98      0.98      0.98      2248\n",
      "\n",
      "\n",
      "-----------------------------Training Data-----------------------------------------\n",
      "[[6841    0]\n",
      " [   3 2146]]\n",
      "0.9996662958843159\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00      6841\n",
      "           1       1.00      1.00      1.00      2149\n",
      "\n",
      "   micro avg       1.00      1.00      1.00      8990\n",
      "   macro avg       1.00      1.00      1.00      8990\n",
      "weighted avg       1.00      1.00      1.00      8990\n",
      "\n",
      "\n",
      "-------------------------Testing Data-------------------------------------------\n",
      "[[1686   36]\n",
      " [  12  514]]\n",
      "0.9786476868327402\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.98      0.99      1722\n",
      "           1       0.93      0.98      0.96       526\n",
      "\n",
      "   micro avg       0.98      0.98      0.98      2248\n",
      "   macro avg       0.96      0.98      0.97      2248\n",
      "weighted avg       0.98      0.98      0.98      2248\n",
      "\n",
      "\n",
      "-----------------------------Training Data-----------------------------------------\n",
      "[[6841    0]\n",
      " [   0 2149]]\n",
      "1.0\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00      6841\n",
      "           1       1.00      1.00      1.00      2149\n",
      "\n",
      "   micro avg       1.00      1.00      1.00      8990\n",
      "   macro avg       1.00      1.00      1.00      8990\n",
      "weighted avg       1.00      1.00      1.00      8990\n",
      "\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------Testing Data-------------------------------------------\n",
      "[[1686   36]\n",
      " [  12  514]]\n",
      "0.9786476868327402\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.98      0.99      1722\n",
      "           1       0.93      0.98      0.96       526\n",
      "\n",
      "   micro avg       0.98      0.98      0.98      2248\n",
      "   macro avg       0.96      0.98      0.97      2248\n",
      "weighted avg       0.98      0.98      0.98      2248\n",
      "\n",
      "\n",
      "-----------------------------Training Data-----------------------------------------\n",
      "[[6841    0]\n",
      " [   0 2149]]\n",
      "1.0\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00      6841\n",
      "           1       1.00      1.00      1.00      2149\n",
      "\n",
      "   micro avg       1.00      1.00      1.00      8990\n",
      "   macro avg       1.00      1.00      1.00      8990\n",
      "weighted avg       1.00      1.00      1.00      8990\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "\n",
    "def testingData(df):\n",
    "    for index,row in df.iterrows():\n",
    "        testing(row,root)\n",
    "w=1\n",
    "# while w>=4:\n",
    "dep=[]\n",
    "nod=[]\n",
    "errorTest=[]\n",
    "errorTestNode=[]\n",
    "errorTrain=[]\n",
    "errorTrainNode=[]\n",
    "# w=20\n",
    "while w<21:\n",
    "    node_count=0\n",
    "    root=buildTree(df,w)\n",
    "#     print(root.value)\n",
    "\n",
    "\n",
    "    copyX_test=copy.deepcopy(testX)\n",
    "    y1=[] \n",
    "    testingData(X_test)  \n",
    "#     print(len(y1))\n",
    "    print(\"-------------------------Testing Data-------------------------------------------\")\n",
    "#     print(y_test)\n",
    "#     print(type(y_test))\n",
    "#     print(y1)\n",
    "#     print(type(y1))\n",
    "    print(confusion_matrix(y_test, y1))  \n",
    "    print(accuracy_score(y_test,y1))\n",
    "    dep.append(w+1)\n",
    "    errorTest.append(1-accuracy_score(y_test,y1))\n",
    "    nod.append(node_count)\n",
    "#     errorTestNode[node_count]=1-accuracy_score(y_test,y1)\n",
    "    print(classification_report(y_test, y1)) \n",
    "    print()\n",
    "    y1.clear()\n",
    "    copyorignalX=copy.deepcopy(orignalX)\n",
    "\n",
    "    testingData(copyorignalX)\n",
    "    # \n",
    "#     print(len(y1))\n",
    "    print(\"-----------------------------Training Data-----------------------------------------\")\n",
    "    # orignalY=copy.deepcopy(y_train)\n",
    "    print(confusion_matrix(orignalY, y1))  \n",
    "    print(accuracy_score(orignalY,y1))\n",
    "    errorTrain.append(1-accuracy_score(orignalY,y1))\n",
    "#     errorTrainNode[node_count]=1-accuracy_score(orignalY,y1)\n",
    "    print(classification_report(orignalY, y1)) \n",
    "    print()\n",
    "    w=w+2\n",
    "# print(errorTest)\n",
    "# print(errorTestNode)\n",
    "# print(errorTrain)\n",
    "# print(errorTrainNode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Depth vs Error')"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_axis = [i for i in range(2,21,2)]\n",
    "# figure()\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "# y_axis=\n",
    "# plt.ylim(0.10,0.13)\n",
    "ax.plot(x_axis, errorTrain, label=\"Training error\",marker=\"o\")\n",
    "ax.plot(x_axis, errorTest, label=\"Testing error\",marker=\"o\")\n",
    "# t = np.arange(-5.0, 5.0, 0.01)\n",
    "ax.legend(loc=2) # upper left corner\n",
    "ax.set_xlabel(\"Depth\", fontsize=10)\n",
    "ax.set_ylabel(\"Error\", fontsize=10)\n",
    "ax.set_title('Depth vs Error')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Node vs Error')"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_axis =nod\n",
    "fig, ax = plt.subplots()\n",
    "# y_axis=\n",
    "# plt.ylim(0.10,0.13)\n",
    "ax.plot(x_axis, errorTrain, label=\"Training error\",marker=\"o\")\n",
    "ax.plot(x_axis, errorTest, label=\"Testing error\",marker=\"o\")\n",
    "# t = np.arange(-5.0, 5.0, 0.01)\n",
    "ax.legend(loc=2) # upper left corner\n",
    "ax.set_xlabel(\"Node\", fontsize=10)\n",
    "ax.set_ylabel(\"Error\", fontsize=10)\n",
    "ax.set_title('Node vs Error')"
   ]
  }
 ],
 "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}