HW6_P1_Team18_Kishore_updated_2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     feature category  survived\n",
      "0     gender   female       1.0\n",
      "1     gender     male       0.0\n",
      "2     pclass        1       1.0\n",
      "3     pclass        2       0.0\n",
      "4     pclass        3       0.0\n",
      "5      sibsp        0       0.0\n",
      "6      sibsp        1       1.0\n",
      "7      sibsp        2       0.0\n",
      "8      sibsp        3       0.0\n",
      "9      sibsp        4       0.0\n",
      "10     sibsp        5       0.0\n",
      "11     sibsp        8       0.0\n",
      "12     parch        0       0.0\n",
      "13     parch        1       1.0\n",
      "14     parch        2       1.0\n",
      "15     parch        3       1.0\n",
      "16     parch        4       0.0\n",
      "17     parch        5       0.0\n",
      "18     parch        6       0.0\n",
      "19     parch        9       0.0\n",
      "20  embarked        C       1.0\n",
      "21  embarked        Q       0.0\n",
      "22  embarked        S       0.0\n",
      "                     Feature  Success Rate \n",
      "0    Gender_Based_Prediction           77.0\n",
      "1    pclass_Based_Prediction           68.0\n",
      "2     sibsp_Based_Prediction           61.0\n",
      "3     parch_Based_Prediction           65.0\n",
      "4  embarked_Based_Prediction           63.0\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import openpyxl\n",
    "\n",
    "class Binaryclass:\n",
    "    \n",
    "    #attributes\n",
    "    train = ''\n",
    "    test = ''\n",
    "    trueclass_train = ''\n",
    "    format_perfsheet= True   \n",
    "    \n",
    "    #create mapping dataframe    \n",
    "    df_result = pd.DataFrame\n",
    "    df_prediction = pd.DataFrame \n",
    "    df_successrate = pd.DataFrame\n",
    "        \n",
    "    #define initialization function\n",
    "    def __init__(self,train,test,trueclass_train):\n",
    "        self.train = train\n",
    "        self.test = test\n",
    "        self.trueclass_train = trueclass_train\n",
    "        result_data = {'feature':[],'category':[],'survived':[]}\n",
    "        self.df_result = pd.DataFrame(result_data)  \n",
    "    \n",
    "    #2.\tConstruct a machine learning model using OneR \n",
    "    #for features: gender, pclass, sibsp, parch, #embarked. [50 points; 10 points per feature]    \n",
    "    def OneR_model(self,col_name,is_test):\n",
    "        #intialising data\n",
    "        if is_test:\n",
    "            df = self.test\n",
    "            df_column = self.test[col_name]\n",
    "        else:\n",
    "            df = self.train\n",
    "            df_column = self.train[col_name]            \n",
    "        \n",
    "        #check NA or null values and forward fill\n",
    "        if df_column.isnull().values.any():\n",
    "            df_column = df_column.fillna(method ='ffill') \n",
    "        \n",
    "        #extracting unique category values in the column\n",
    "        unique_values = np.unique(df_column)\n",
    "   \n",
    "        #filter ID column         \n",
    "        self.df_prediction = df.filter(items = ['ID'])\n",
    "        self.df_prediction['Prediction'] = np.NaN                \n",
    "        \n",
    "        #for each category in the column majority survival value is calculated\n",
    "        for category in unique_values:\n",
    "            #calculating majority survival value for a category\n",
    "            is_category = (df_column == category)\n",
    "            \n",
    "            #For test data accessing class from training result dataframe\n",
    "            if is_test:\n",
    "                \n",
    "                classifier = self.df_result['survived'][(self.df_result['category']==category) & \n",
    "                                                        (self.df_result['feature'] == col_name)]\n",
    "                #adding prediction column to the dataframe\n",
    "                #self.df_prediction['Prediction'][is_category] = int(classifier)\n",
    "                self.df_prediction.loc[is_category,'Prediction'] = int(classifier)\n",
    "            \n",
    "            #For train data creating OneR model classifier\n",
    "            else:\n",
    "                ser_survived_count = self.trueclass_train[is_category].value_counts()\n",
    "                #saving majority survival value as classifier\n",
    "                if ser_survived_count.size == 2:\n",
    "                    classifier = ser_survived_count[1] > ser_survived_count[0]\n",
    "                else:\n",
    "                    classifier = ser_survived_count.index[0]\n",
    "\n",
    "                #creating dataframe with ID and prediction                \n",
    "                self.df_prediction.loc[is_category,'Prediction'] = int(classifier)\n",
    "                #saving it in a dataframe\n",
    "                append_data = {'feature':col_name,'category':category,'survived':classifier}\n",
    "                self.df_result = self.df_result.append(append_data,ignore_index = True)\n",
    "\n",
    "        #writing excel sheet with given column name\n",
    "        req_sheetname = col_name+ \"_Based_Prediction\"\n",
    "        if is_test:\n",
    "            filename_dest = \"titanic_test_predictions.xlsx\"\n",
    "            self.Write_TestExcel(filename_dest,req_sheetname)\n",
    "            \n",
    "        return self.df_result\n",
    "      \n",
    "    #4.For each feature, store the passenger IDs and class labels in the appropriate worksheet \n",
    "    #(e.g., Gender_Based_Prediction for gender based OneR) of the attached output file (titanic_test_predictions.xlsx). \n",
    "    #writing excel sheet with given column name for Test set with Predictions\n",
    "    def Write_TestExcel(self,filename_dest,sheetname_dest):\n",
    "        \n",
    "        #checking for gender_Based_Prediction sheet's name\n",
    "        if sheetname_dest == 'gender_Based_Prediction':\n",
    "            sheetname_dest = 'Gender_Based_Prediction'            \n",
    "        \n",
    "        #read target file titanic_test_predictions.xslx\n",
    "        df_source = pd.read_excel(filename_dest, sheet_name=sheetname_dest)\n",
    "        df_source = df_source.filter(items = ['ID','Ground truth'])\n",
    "        \n",
    "        #creating new dataframe with above columns and prediction column\n",
    "        df_final = pd.merge(df_source, self.df_prediction, on='ID', how='inner')\n",
    "        \n",
    "        #calculate prediction success rate\n",
    "        success_rate = self.Calc_Successrate(df_final)        \n",
    "        \n",
    "        #update performance in appropriate sheet\n",
    "        sheet_performance = 'Prediction_Success_Rate'        \n",
    "        Feature = sheetname_dest        \n",
    "        self.Write_Successrate(filename_dest,sheet_performance,success_rate,Feature)        \n",
    "        \n",
    "        #Delete existing sheet\n",
    "        self.Del_Sheet(filename_dest,sheetname_dest)\n",
    "        \n",
    "        #if file doesn't exist use write 'w' mode, else use appendmode 'a'\n",
    "        if not os.path.isfile(filename_dest):\n",
    "            write_mode = 'w'\n",
    "        else:\n",
    "            write_mode= 'a'    \n",
    "    \n",
    "        with pd.ExcelWriter(filename_dest,engine='openpyxl',mode=write_mode) as writer:\n",
    "            df_final.to_excel(writer, sheet_name=sheetname_dest,index=False)\n",
    "            # Close the Pandas Excel writer and output the Excel file.\n",
    "            writer.save()\n",
    "            \n",
    "    #5.Compute success rate for the test set.\n",
    "    #Success rate is the total number of correct predictions divide by the total instances. [10 points]\n",
    "    def Calc_Successrate(self,df_input):\n",
    "        pred_difference = sum(abs(df_input['Ground truth']-df_input['Prediction']))\n",
    "        total_rows = df_input['Ground truth'].shape[0]\n",
    "        error_rate = pred_difference/total_rows\n",
    "        success_rate = round(1-error_rate,2)\n",
    "\n",
    "        return success_rate\n",
    "    \n",
    "    #updating excel sheet with success rate of each model in Prediction_Success_Rate sheet\n",
    "    def Write_Successrate(self,filename_dest,sheet_performance,success_rate,Feature):\n",
    "        df_source = pd.read_excel(filename_dest, sheet_name=sheet_performance)\n",
    "        \n",
    "        is_category = (df_source['Feature'] == Feature)\n",
    "        if self.format_perfsheet:\n",
    "            df_source.loc[is_category,'Success Rate '] = success_rate\n",
    "            format = lambda x: (x*100)\n",
    "            df_source['Success Rate '] = df_source['Success Rate '].map(format)\n",
    "            self.format_perfsheet = False\n",
    "        else:\n",
    "            df_source.loc[is_category,'Success Rate '] = success_rate*100\n",
    "        \n",
    "        #assigning result to class' attribute\n",
    "        self.df_successrate = df_source\n",
    "        #Delete existing sheet\n",
    "        self.Del_Sheet(filename_dest,sheet_performance)\n",
    "        #creating new sheet with updated data\n",
    "        with pd.ExcelWriter(filename_dest,engine='openpyxl',mode='a') as writer:\n",
    "            df_source.to_excel(writer, sheet_name=sheet_performance,index=False)\n",
    "            # Save the Pandas Excel writer and output the Excel file.\n",
    "            writer.save()\n",
    "        \n",
    "    #deleting existing sheet in workbook\n",
    "    def Del_Sheet(self,filename_dest,sheetname_dest):        \n",
    "        workbook=openpyxl.load_workbook(filename_dest)        \n",
    "        del workbook[sheetname_dest]        \n",
    "        workbook.save(filename_dest)\n",
    "        workbook.close()1\n",
    "        \n",
    "#changing directory to required path\n",
    "required_path = r\"F:\\Programming\\Python\"\n",
    "os.chdir(required_path)\n",
    "\n",
    "# 1.\tRead-in the training set and test set.\n",
    "#Reading train and test files as dataframes\n",
    "train_file_name = \"titanic_traning.xlsx\"\n",
    "test_file_name = \"titanic_test.xlsx\"\n",
    "df_train = pd.read_excel(train_file_name)\n",
    "df_test = pd.read_excel(test_file_name)\n",
    "trueclass_train = df_train['survived']\n",
    "\n",
    "#creating object of Binary classifier class\n",
    "Titanic = Binaryclass(df_train,df_test,trueclass_train)\n",
    "#2.\tConstruct a machine learning model using OneR for each of the following features: \n",
    "#gender, pclass, sibsp, parch, embarked. [50 points; 10 points per feature]\n",
    "Titanic.OneR_model('gender',is_test = False)\n",
    "Titanic.OneR_model('pclass',is_test = False)\n",
    "Titanic.OneR_model('sibsp',is_test = False)\n",
    "Titanic.OneR_model('parch',is_test = False)\n",
    "Titanic.OneR_model('embarked',is_test = False)\n",
    "\n",
    "#OneR model for given training set\n",
    "print(Titanic.df_result)\n",
    "\n",
    "#3.For each feature, predict class label (survived or not survived)for every passenger in the test set. [10 points]\n",
    "#4.For each feature, store the passenger IDs and class labels in the appropriate worksheet \n",
    "#(e.g., Gender_Based_Prediction for gender based OneR) of the attached output file (titanic_test_predictions.xlsx). \n",
    "Titanic.OneR_model('gender',is_test = True)\n",
    "Titanic.OneR_model('pclass',is_test = True)\n",
    "Titanic.OneR_model('sibsp',is_test = True)\n",
    "Titanic.OneR_model('parch',is_test = True)\n",
    "Titanic.OneR_model('embarked',is_test = True)\n",
    "\n",
    "#5.Compute success rate for the test set.\n",
    "#Success rate is the total number of correct predictions divide by the total instances. [10 points]\n",
    "print(Titanic.df_successrate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}