1_modeling.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3c6aa7d9",
   "metadata": {},
   "source": [
    "# Feature level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "56d44245",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.inspection import permutation_importance\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.preprocessing import OneHotEncoder, StandardScaler\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.dummy import DummyClassifier\n",
    "from sklearn.model_selection import cross_val_score, GridSearchCV, cross_validate\n",
    "from sklearn.metrics import f1_score, recall_score, precision_score\n",
    "from sklearn.decomposition import PCA\n",
    "from sklearn.metrics import precision_score, recall_score, f1_score, classification_report"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a735e2b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df_train = pd.read_pickle('df_train_prep.p')\n",
    "df_test = pd.read_pickle('df_test_prep.p')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1be93a7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "#instantiate feature matrix and target vector for train set\n",
    "features_train = df_train.drop(\"IsBadBuy\", axis=1)\n",
    "target_train = df_train.loc[:, \"IsBadBuy\"]\n",
    "\n",
    "#for testing\n",
    "features_train_copy = features_train.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "88f6228a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.876158\n",
       "1    0.123842\n",
       "Name: IsBadBuy, dtype: float64"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#class distribution\n",
    "target_train.value_counts(normalize=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "983427a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#instantiate feature matrix and target vector for test set\n",
    "features_test = df_test.drop(\"IsBadBuy\", axis=1)\n",
    "target_test = df_test.loc[:, \"IsBadBuy\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "dfc03dc8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 58373 entries, 0 to 58372\n",
      "Data columns (total 25 columns):\n",
      " #   Column                             Non-Null Count  Dtype   \n",
      "---  ------                             --------------  -----   \n",
      " 0   Auction                            58373 non-null  category\n",
      " 1   VehicleAge                         58373 non-null  int64   \n",
      " 2   Make                               58373 non-null  category\n",
      " 3   Trim                               58373 non-null  category\n",
      " 4   Color                              58373 non-null  category\n",
      " 5   Transmission                       58373 non-null  category\n",
      " 6   WheelType                          58373 non-null  category\n",
      " 7   VehOdo                             58373 non-null  int64   \n",
      " 8   Nationality                        58373 non-null  category\n",
      " 9   Size                               58373 non-null  category\n",
      " 10  TopThreeAmericanName               58373 non-null  category\n",
      " 11  MMRAcquisitionAuctionAveragePrice  58373 non-null  float64 \n",
      " 12  MMRAcquisitionAuctionCleanPrice    58373 non-null  float64 \n",
      " 13  MMRAcquisitionRetailAveragePrice   58373 non-null  float64 \n",
      " 14  MMRAcquisitonRetailCleanPrice      58373 non-null  float64 \n",
      " 15  MMRCurrentAuctionAveragePrice      58373 non-null  float64 \n",
      " 16  MMRCurrentAuctionCleanPrice        58373 non-null  float64 \n",
      " 17  MMRCurrentRetailAveragePrice       58373 non-null  float64 \n",
      " 18  MMRCurrentRetailCleanPrice         58373 non-null  float64 \n",
      " 19  BYRNO                              58373 non-null  category\n",
      " 20  VNST                               58373 non-null  category\n",
      " 21  VehBCost                           58373 non-null  float64 \n",
      " 22  IsOnlineSale                       58373 non-null  category\n",
      " 23  WarrantyCost                       58373 non-null  int64   \n",
      " 24  PurchYear                          58373 non-null  int64   \n",
      "dtypes: category(12), float64(9), int64(4)\n",
      "memory usage: 6.5 MB\n"
     ]
    }
   ],
   "source": [
    "features_train.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "1fa6d581",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.19580426673003526"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# baseline model: randomly predicting the same number of cases in each class\n",
    "model_dummy = DummyClassifier(strategy='uniform', random_state=42)\n",
    "\n",
    "cross_val_score(estimator=model_dummy,\n",
    "                X=features_train, \n",
    "                y=target_train, \n",
    "                cv=3, \n",
    "                scoring='f1').mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "de4202f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Auction                   3\n",
       "Make                     33\n",
       "Trim                    133\n",
       "Color                    16\n",
       "Transmission              2\n",
       "WheelType                 3\n",
       "Nationality               4\n",
       "Size                     12\n",
       "TopThreeAmericanName      4\n",
       "BYRNO                    72\n",
       "VNST                     37\n",
       "IsOnlineSale              2\n",
       "dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "features_train.select_dtypes('category').nunique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "34ca57f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['AUTO', 'MANUAL']\n",
       "Categories (2, object): ['AUTO', 'MANUAL']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "features_train.loc[:, 'Transmission'].unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0f60ad60",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\dk\\AppData\\Local\\Temp\\ipykernel_10880\\1451359090.py:2: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n",
      "  features_train.loc[:, 'Transmission'] = features_train.loc[:, 'Transmission'].replace({'AUTO':0, 'MANUAL':1})\n",
      "C:\\Users\\dk\\AppData\\Local\\Temp\\ipykernel_10880\\1451359090.py:3: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n",
      "  features_train.loc[:, 'Transmission'] = features_train.loc[:, 'Transmission'].astype('category')\n"
     ]
    }
   ],
   "source": [
    "# dummy coding\n",
    "features_train.loc[:, 'Transmission'] = features_train.loc[:, 'Transmission'].replace({'AUTO':0, 'MANUAL':1})\n",
    "features_train.loc[:, 'Transmission'] = features_train.loc[:, 'Transmission'].astype('category')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8dfba6bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['Auction', 'Make', 'Trim', 'Color', 'Transmission', 'WheelType',\n",
       "       'Nationality', 'Size', 'TopThreeAmericanName', 'BYRNO', 'VNST',\n",
       "       'IsOnlineSale'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "features_train.select_dtypes('category').columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a9dd449d",
   "metadata": {},
   "outputs": [],
   "source": [
    "ohe_cols = ['Auction', \n",
    "            'Make',\n",
    "            'Trim',\n",
    "            'Color', \n",
    "            'WheelType',\n",
    "            'Nationality', \n",
    "            'Size', \n",
    "            'TopThreeAmericanName', \n",
    "            'BYRNO', \n",
    "            'VNST']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4a783f47",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['VehicleAge', 'VehOdo', 'MMRAcquisitionAuctionAveragePrice',\n",
       "       'MMRAcquisitionAuctionCleanPrice', 'MMRAcquisitionRetailAveragePrice',\n",
       "       'MMRAcquisitonRetailCleanPrice', 'MMRCurrentAuctionAveragePrice',\n",
       "       'MMRCurrentAuctionCleanPrice', 'MMRCurrentRetailAveragePrice',\n",
       "       'MMRCurrentRetailCleanPrice', 'VehBCost', 'WarrantyCost', 'PurchYear'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "features_train.select_dtypes('number').columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "63158fb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_cols = ['VehicleAge', \n",
    "            'VehOdo', \n",
    "            'MMRAcquisitionAuctionAveragePrice',\n",
    "            'MMRAcquisitionAuctionCleanPrice', \n",
    "            'MMRAcquisitionRetailAveragePrice',\n",
    "            'MMRAcquisitonRetailCleanPrice', \n",
    "            'MMRCurrentAuctionAveragePrice',\n",
    "            'MMRCurrentAuctionCleanPrice', \n",
    "            'MMRCurrentRetailAveragePrice',\n",
    "            'MMRCurrentRetailCleanPrice', \n",
    "            'VehBCost', \n",
    "            'WarrantyCost',\n",
    "            'PurchYear']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "66a29cb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "num_cols = features_train.select_dtypes('category').columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7fd7ea2c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# one-hot encoding categorial columns and standardising mmr colums to handle high correlations\n",
    "col_transformer = ColumnTransformer(transformers=[(\"OHE\", \n",
    "                                                   OneHotEncoder(handle_unknown=\"ignore\", \n",
    "                                                                 drop='first'), \n",
    "                                                   ohe_cols)],\n",
    "                                    remainder=\"passthrough\",\n",
    "                                    sparse_threshold=0)\n",
    "\n",
    "scaler = StandardScaler()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "90f5fea6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\dk\\anaconda3\\lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:202: UserWarning: Found unknown categories in columns [1, 2] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "C:\\Users\\dk\\anaconda3\\lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:202: UserWarning: Found unknown categories in columns [2, 8] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "C:\\Users\\dk\\anaconda3\\lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:202: UserWarning: Found unknown categories in columns [2] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "C:\\Users\\dk\\anaconda3\\lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:202: UserWarning: Found unknown categories in columns [2, 8] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "C:\\Users\\dk\\anaconda3\\lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:202: UserWarning: Found unknown categories in columns [1, 2, 8] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "# simple model\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "baseline_lr = LogisticRegression(class_weight=\"balanced\",\n",
    "                                 random_state=42,\n",
    "                                 max_iter=1000)\n",
    "\n",
    "pipe_base = Pipeline([(\"col_encoder\", col_transformer),\n",
    "                      (\"scaler\", scaler),\n",
    "                      (\"model\", baseline_lr)])\n",
    "\n",
    "pipe_base.fit(features_train, target_train)\n",
    "\n",
    "cv_results = cross_validate(estimator=pipe_base, \n",
    "                            X=features_train, \n",
    "                            y=target_train, \n",
    "                            cv=5, \n",
    "                            scoring=['precision', 'recall', 'f1'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "a4283b23",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'fit_time': array([3.08083987, 3.47083378, 3.05576229, 3.39761472, 2.94306183]),\n",
       " 'score_time': array([0.06001019, 0.05802584, 0.05664015, 0.05867863, 0.05854273]),\n",
       " 'test_precision': array([0.19845028, 0.19716727, 0.2021692 , 0.20292066, 0.20255434]),\n",
       " 'test_recall': array([0.63762102, 0.60650069, 0.64453665, 0.64429066, 0.62517289]),\n",
       " 'test_f1': array([0.30269206, 0.29759077, 0.30779392, 0.30863584, 0.30597394])}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cv_results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "4bc166e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "precision:  0.20065234832827042\n",
      "recall:  0.6316243832167966\n",
      "f1:  0.3045373046211116\n"
     ]
    }
   ],
   "source": [
    "print('precision: ', list(cv_results.values())[2].mean())\n",
    "print('recall: ', list(cv_results.values())[3].mean())\n",
    "print('f1: ', list(cv_results.values())[4].mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "08a36eb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# feature engineering\n",
    "\n",
    "# calculating average prices of MMR prices\n",
    "MMR_cols = ['MMRAcquisitionAuctionAveragePrice',\n",
    "            'MMRAcquisitionAuctionCleanPrice',\n",
    "            'MMRAcquisitionRetailAveragePrice',\n",
    "            'MMRAcquisitonRetailCleanPrice',\n",
    "            'MMRCurrentAuctionAveragePrice',\n",
    "            'MMRCurrentAuctionCleanPrice',\n",
    "            'MMRCurrentRetailAveragePrice',\n",
    "            'MMRCurrentRetailCleanPrice']\n",
    "\n",
    "features_train['AvgPrice'] = sum(features_train[col] for col in MMR_cols) / len(MMR_cols)\n",
    "\n",
    "# calculating average prices of Auctions\n",
    "MMR_auction = ['MMRAcquisitionAuctionAveragePrice',\n",
    "               'MMRAcquisitionAuctionCleanPrice',\n",
    "               'MMRCurrentAuctionAveragePrice',\n",
    "               'MMRCurrentAuctionCleanPrice']\n",
    "\n",
    "features_train['AvgPrice_Auction'] = sum(features_train[col] for col in MMR_auction) / len(MMR_auction)\n",
    "\n",
    "# calculating average prices of Retails\n",
    "MMR_retail = ['MMRAcquisitionAuctionAveragePrice',\n",
    "              'MMRAcquisitionAuctionCleanPrice',\n",
    "              'MMRCurrentAuctionAveragePrice',\n",
    "              'MMRCurrentAuctionCleanPrice']\n",
    "\n",
    "features_train['AvgPrice_Retail'] = sum(features_train[col] for col in MMR_retail) / len(MMR_retail)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "16039ed8",
   "metadata": {},
   "outputs": [],
   "source": [
    "#feature engineering function\n",
    "def feature_engineering(features):\n",
    "    \"\"\"\n",
    "    Engineers features and selects most important ones.\n",
    "\n",
    "    Args:\n",
    "        features (pd.DataFrame) : Feature matrix\n",
    "\n",
    "    Returns:\n",
    "        features (pd.DataFrame) : Selected feature matrix.\n",
    "    \"\"\"\n",
    "    \n",
    "    # dummy coding\n",
    "    features.loc[:, 'Transmission'] = features.loc[:, 'Transmission'].replace({'AUTO':0, 'MANUAL':1})\n",
    "    features.loc[:, 'Transmission'] = features.loc[:, 'Transmission'].astype('category')\n",
    "\n",
    "    ohe_cols = ['Auction',\n",
    "                'Make',\n",
    "                'Trim',\n",
    "                'Color',\n",
    "                'WheelType',\n",
    "                'Nationality',\n",
    "                'Size',\n",
    "                'TopThreeAmericanName',\n",
    "                'BYRNO',\n",
    "                'VNST']\n",
    "\n",
    "    num_cols = ['VehicleAge',\n",
    "                'VehOdo',\n",
    "                'MMRAcquisitionAuctionAveragePrice',\n",
    "                'MMRAcquisitionAuctionCleanPrice',\n",
    "                'MMRAcquisitionRetailAveragePrice',\n",
    "                'MMRAcquisitonRetailCleanPrice',\n",
    "                'MMRCurrentAuctionAveragePrice',\n",
    "                'MMRCurrentAuctionCleanPrice',\n",
    "                'MMRCurrentRetailAveragePrice',\n",
    "                'MMRCurrentRetailCleanPrice',\n",
    "                'VehBCost',\n",
    "                'WarrantyCost',\n",
    "                'PurchYear']\n",
    "\n",
    "    MMR_cols = ['MMRAcquisitionAuctionAveragePrice',\n",
    "                'MMRAcquisitionAuctionCleanPrice',\n",
    "                'MMRAcquisitionRetailAveragePrice',\n",
    "                'MMRAcquisitonRetailCleanPrice',\n",
    "                'MMRCurrentAuctionAveragePrice',\n",
    "                'MMRCurrentAuctionCleanPrice',\n",
    "                'MMRCurrentRetailAveragePrice',\n",
    "                'MMRCurrentRetailCleanPrice']\n",
    "\n",
    "    features['AvgPrice'] = sum(features[col] for col in MMR_cols) / len(MMR_cols)\n",
    "\n",
    "    MMR_auction = ['MMRAcquisitionAuctionAveragePrice',\n",
    "                   'MMRAcquisitionAuctionCleanPrice',\n",
    "                   'MMRCurrentAuctionAveragePrice',\n",
    "                   'MMRCurrentAuctionCleanPrice']\n",
    "    features['AvgPrice_Auction'] = sum(features[col]\n",
    "                                 for col in MMR_auction) / len(MMR_auction)\n",
    "\n",
    "    MMR_retail = ['MMRAcquisitionAuctionAveragePrice',\n",
    "                  'MMRAcquisitionAuctionCleanPrice',\n",
    "                  'MMRCurrentAuctionAveragePrice',\n",
    "                  'MMRCurrentAuctionCleanPrice']\n",
    "    features['AvgPrice_Retail'] = sum(features[col]\n",
    "                                for col in MMR_retail) / len(MMR_retail)\n",
    "\n",
    "    return features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "61d81041",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\dk\\AppData\\Local\\Temp\\ipykernel_10880\\2203189024.py:14: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n",
      "  features.loc[:, 'Transmission'] = features.loc[:, 'Transmission'].replace({'AUTO':0, 'MANUAL':1})\n",
      "C:\\Users\\dk\\AppData\\Local\\Temp\\ipykernel_10880\\2203189024.py:15: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n",
      "  features.loc[:, 'Transmission'] = features.loc[:, 'Transmission'].astype('category')\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#test function\n",
    "features_train_eng = feature_engineering(features_train_copy)\n",
    "(features_train_eng.equals(features_train))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d6dcfb92",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\dk\\anaconda3\\lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:202: UserWarning: Found unknown categories in columns [1, 2] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "C:\\Users\\dk\\anaconda3\\lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:202: UserWarning: Found unknown categories in columns [2, 8] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "C:\\Users\\dk\\anaconda3\\lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:202: UserWarning: Found unknown categories in columns [2] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "C:\\Users\\dk\\anaconda3\\lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:202: UserWarning: Found unknown categories in columns [2, 8] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n",
      "C:\\Users\\dk\\anaconda3\\lib\\site-packages\\sklearn\\preprocessing\\_encoders.py:202: UserWarning: Found unknown categories in columns [1, 2, 8] during transform. These unknown categories will be encoded as all zeros\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'fit_time': array([3.40407634, 3.59428644, 4.15136766, 3.89281368, 3.17682981]),\n",
       " 'score_time': array([0.05947948, 0.0580008 , 0.06306171, 0.06700325, 0.05951118]),\n",
       " 'test_precision': array([0.19836489, 0.19730034, 0.20203772, 0.20300916, 0.20242098]),\n",
       " 'test_recall': array([0.63762102, 0.60650069, 0.64453665, 0.64429066, 0.62448133]),\n",
       " 'test_f1': array([0.30259271, 0.29774232, 0.30764153, 0.30873819, 0.30573895])}"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dimensionality reduction\n",
    "pca_col_transformer = ColumnTransformer(transformers=[(\"OHE\", \n",
    "                                                       OneHotEncoder(handle_unknown=\"ignore\", \n",
    "                                                                     drop='first'), \n",
    "                                                       ohe_cols),                                                      \n",
    "                                                      (\"PCA_MMR\", \n",
    "                                                       PCA(n_components=1, \n",
    "                                                           random_state=42), \n",
    "                                                       MMR_cols)],\n",
    "                                        remainder=\"passthrough\",\n",
    "                                        sparse_threshold=0)\n",
    "                                         \n",
    "base_pca_pipe = Pipeline([(\"col_encoder\", pca_col_transformer),\n",
    "                          (\"scaler\", scaler),\n",
    "                          (\"model\", baseline_lr)])\n",
    "                          \n",
    "base_pca_pipe.fit(features_train, target_train)\n",
    "\n",
    "cross_validate(estimator=pipe_base, X=features_train, y=target_train, cv=5, scoring=['precision', 'recall', 'f1'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "594852c5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "precision:  0.20065234832827042\n",
      "recall:  0.6316243832167966\n",
      "f1:  0.3045373046211116\n"
     ]
    }
   ],
   "source": [
    "print('precision: ', list(cv_results.values())[2].mean())\n",
    "print('recall: ', list(cv_results.values())[3].mean())\n",
    "print('f1: ', list(cv_results.values())[4].mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "486b1d5f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# feature importance\n",
    "result = permutation_importance(base_pca_pipe, features_train, target_train, random_state=42)\n",
    "sorted_idx = result.importances_mean.argsort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "65370ef5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "pd.Series(data=result.importances_mean[sorted_idx].T,\n",
    "          index=features_train.columns[sorted_idx]).plot.bar(ax=ax);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "b286f42c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Auction', 'VNST', 'Trim', 'WheelType', 'PurchYear', 'Nationality', 'VehBCost', 'AvgPrice_Auction', 'AvgPrice_Retail', 'TopThreeAmericanName', 'Make', 'AvgPrice']\n"
     ]
    }
   ],
   "source": [
    "keep_cols = list(features_train.columns[sorted_idx][-12:])\n",
    "print(keep_cols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "02c645ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['BYRNO', 'VehOdo', 'VehicleAge', 'IsOnlineSale', 'MMRCurrentRetailAveragePrice', 'MMRAcquisitionRetailAveragePrice', 'MMRCurrentAuctionAveragePrice', 'MMRAcquisitionAuctionAveragePrice', 'MMRCurrentAuctionCleanPrice', 'MMRAcquisitionAuctionCleanPrice', 'MMRAcquisitonRetailCleanPrice', 'MMRCurrentRetailCleanPrice', 'Size', 'Color', 'Transmission', 'WarrantyCost']\n"
     ]
    }
   ],
   "source": [
    "remove_cols = [col for col in features_train.columns[sorted_idx] if col not in keep_cols]\n",
    "print(remove_cols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "420590bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "features_train = features_train.drop(remove_cols, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "0d2b67e4",
   "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>Auction</th>\n",
       "      <th>Make</th>\n",
       "      <th>Trim</th>\n",
       "      <th>WheelType</th>\n",
       "      <th>Nationality</th>\n",
       "      <th>TopThreeAmericanName</th>\n",
       "      <th>VNST</th>\n",
       "      <th>VehBCost</th>\n",
       "      <th>PurchYear</th>\n",
       "      <th>AvgPrice</th>\n",
       "      <th>AvgPrice_Auction</th>\n",
       "      <th>AvgPrice_Retail</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>MANHEIM</td>\n",
       "      <td>FORD</td>\n",
       "      <td>SEL</td>\n",
       "      <td>Alloy</td>\n",
       "      <td>AMERICAN</td>\n",
       "      <td>FORD</td>\n",
       "      <td>NC</td>\n",
       "      <td>8000.0</td>\n",
       "      <td>2009</td>\n",
       "      <td>13361.000</td>\n",
       "      <td>12606.75</td>\n",
       "      <td>12606.75</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>MANHEIM</td>\n",
       "      <td>GMC</td>\n",
       "      <td>SLE</td>\n",
       "      <td>Alloy</td>\n",
       "      <td>AMERICAN</td>\n",
       "      <td>GM</td>\n",
       "      <td>MD</td>\n",
       "      <td>7195.0</td>\n",
       "      <td>2009</td>\n",
       "      <td>8893.250</td>\n",
       "      <td>8310.75</td>\n",
       "      <td>8310.75</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>OTHER</td>\n",
       "      <td>DODGE</td>\n",
       "      <td>SE</td>\n",
       "      <td>Alloy</td>\n",
       "      <td>AMERICAN</td>\n",
       "      <td>CHRYSLER</td>\n",
       "      <td>OK</td>\n",
       "      <td>7300.0</td>\n",
       "      <td>2010</td>\n",
       "      <td>9785.625</td>\n",
       "      <td>8155.50</td>\n",
       "      <td>8155.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>OTHER</td>\n",
       "      <td>CHEVROLET</td>\n",
       "      <td>Bas</td>\n",
       "      <td>Covers</td>\n",
       "      <td>AMERICAN</td>\n",
       "      <td>GM</td>\n",
       "      <td>CO</td>\n",
       "      <td>5655.0</td>\n",
       "      <td>2009</td>\n",
       "      <td>4697.500</td>\n",
       "      <td>4276.50</td>\n",
       "      <td>4276.50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>OTHER</td>\n",
       "      <td>HYUNDAI</td>\n",
       "      <td>GLS</td>\n",
       "      <td>Alloy</td>\n",
       "      <td>OTHER ASIAN</td>\n",
       "      <td>OTHER</td>\n",
       "      <td>AL</td>\n",
       "      <td>7900.0</td>\n",
       "      <td>2010</td>\n",
       "      <td>8595.500</td>\n",
       "      <td>6784.25</td>\n",
       "      <td>6784.25</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Auction       Make Trim WheelType  Nationality TopThreeAmericanName VNST  \\\n",
       "0  MANHEIM       FORD  SEL     Alloy     AMERICAN                 FORD   NC   \n",
       "1  MANHEIM        GMC  SLE     Alloy     AMERICAN                   GM   MD   \n",
       "2    OTHER      DODGE   SE     Alloy     AMERICAN             CHRYSLER   OK   \n",
       "3    OTHER  CHEVROLET  Bas    Covers     AMERICAN                   GM   CO   \n",
       "4    OTHER    HYUNDAI  GLS     Alloy  OTHER ASIAN                OTHER   AL   \n",
       "\n",
       "   VehBCost  PurchYear   AvgPrice  AvgPrice_Auction  AvgPrice_Retail  \n",
       "0    8000.0       2009  13361.000          12606.75         12606.75  \n",
       "1    7195.0       2009   8893.250           8310.75          8310.75  \n",
       "2    7300.0       2010   9785.625           8155.50          8155.50  \n",
       "3    5655.0       2009   4697.500           4276.50          4276.50  \n",
       "4    7900.0       2010   8595.500           6784.25          6784.25  "
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "features_train.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c4e15ad",
   "metadata": {},
   "source": [
    "# Algorithm level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "d2c8345d",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\dk\\AppData\\Local\\Temp\\ipykernel_10880\\2203189024.py:14: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n",
      "  features.loc[:, 'Transmission'] = features.loc[:, 'Transmission'].replace({'AUTO':0, 'MANUAL':1})\n",
      "C:\\Users\\dk\\AppData\\Local\\Temp\\ipykernel_10880\\2203189024.py:15: DeprecationWarning: In a future version, `df.iloc[:, i] = newvals` will attempt to set the values inplace instead of always setting a new array. To retain the old behavior, use either `df[df.columns[i]] = newvals` or, if columns are non-unique, `df.isetitem(i, newvals)`\n",
      "  features.loc[:, 'Transmission'] = features.loc[:, 'Transmission'].astype('category')\n"
     ]
    }
   ],
   "source": [
    "# apply feature engineering function on test set\n",
    "features_test = feature_engineering(features_test)\n",
    "features_test = features_test.drop(remove_cols, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "e33d208b",
   "metadata": {},
   "outputs": [],
   "source": [
    "ohe_cols = [col for col in ohe_cols if col not in remove_cols]\n",
    "\n",
    "col_transformer = ColumnTransformer(transformers=[(\"OHE\", OneHotEncoder(handle_unknown=\"ignore\"), ohe_cols)],\n",
    "                                    remainder=\"passthrough\",\n",
    "                                    sparse_threshold=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "638729f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pipeline(steps=[('col_encoder',\n",
      "                 ColumnTransformer(remainder='passthrough', sparse_threshold=0,\n",
      "                                   transformers=[('OHE',\n",
      "                                                  OneHotEncoder(handle_unknown='ignore'),\n",
      "                                                  ['Auction', 'Make', 'Trim',\n",
      "                                                   'WheelType', 'Nationality',\n",
      "                                                   'TopThreeAmericanName',\n",
      "                                                   'VNST'])])),\n",
      "                ('scaler', StandardScaler()),\n",
      "                ('model',\n",
      "                 LogisticRegression(C=0.005, class_weight='balanced',\n",
      "                                    max_iter=1000, random_state=42))])\n",
      "0.29904796842292136\n"
     ]
    }
   ],
   "source": [
    "# logistic regression\n",
    "model_lr = LogisticRegression(class_weight=\"balanced\",\n",
    "                              random_state=42,\n",
    "                              max_iter=1000)\n",
    "\n",
    "model_pipe_lr = Pipeline([(\"col_encoder\", col_transformer),\n",
    "                          (\"scaler\", scaler),\n",
    "                          (\"model\", model_lr)])\n",
    "\n",
    "search_grid_lr = {\"model__C\": [0.005, 0.01, 0.05, 1]}\n",
    "\n",
    "grid_model_lr = GridSearchCV(estimator=model_pipe_lr,\n",
    "                             param_grid=search_grid_lr,\n",
    "                             cv=5,\n",
    "                             scoring=\"f1\")\n",
    "\n",
    "grid_model_lr.fit(features_train, target_train)\n",
    "\n",
    "print(grid_model_lr.best_estimator_)\n",
    "print(grid_model_lr.best_score_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "8d892855",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.92      0.64      0.76     12846\n",
      "           1       0.19      0.61      0.29      1746\n",
      "\n",
      "    accuracy                           0.64     14592\n",
      "   macro avg       0.55      0.62      0.52     14592\n",
      "weighted avg       0.83      0.64      0.70     14592\n",
      "\n"
     ]
    }
   ],
   "source": [
    "target_test_pred = grid_model_lr.predict(features_test)\n",
    "print(classification_report(target_test, target_test_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "e1d5dead",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pipeline(steps=[('col_encoder',\n",
      "                 ColumnTransformer(remainder='passthrough', sparse_threshold=0,\n",
      "                                   transformers=[('OHE',\n",
      "                                                  OneHotEncoder(handle_unknown='ignore'),\n",
      "                                                  ['Auction', 'Make', 'Trim',\n",
      "                                                   'WheelType', 'Nationality',\n",
      "                                                   'TopThreeAmericanName',\n",
      "                                                   'VNST'])])),\n",
      "                ('scaler', StandardScaler()),\n",
      "                ('model', KNeighborsClassifier(n_neighbors=1))])\n",
      "0.20555210888182857\n"
     ]
    }
   ],
   "source": [
    "# knn\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "model_knn = KNeighborsClassifier()\n",
    "\n",
    "# tune hyperparameters\n",
    "model_pipe_knn = Pipeline([(\"col_encoder\", col_transformer),\n",
    "                           (\"scaler\", scaler),\n",
    "                           (\"model\", model_knn)])\n",
    "\n",
    "search_grid_knn = {\"model__n_neighbors\": range(1, 6),\n",
    "                   \"model__weights\": ['uniform', 'distance']}\n",
    "\n",
    "grid_model_knn = GridSearchCV(estimator=model_pipe_knn,\n",
    "                              param_grid=search_grid_knn,\n",
    "                              cv=5,\n",
    "                              scoring=\"f1\")\n",
    "\n",
    "grid_model_knn.fit(features_train, target_train)\n",
    "\n",
    "print(grid_model_knn.best_estimator_)\n",
    "print(grid_model_knn.best_score_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "a6b89031",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.89      0.89      0.89     12846\n",
      "           1       0.19      0.19      0.19      1746\n",
      "\n",
      "    accuracy                           0.81     14592\n",
      "   macro avg       0.54      0.54      0.54     14592\n",
      "weighted avg       0.81      0.81      0.81     14592\n",
      "\n"
     ]
    }
   ],
   "source": [
    "target_test_pred = grid_model_knn.predict(features_test)\n",
    "print(classification_report(target_test, target_test_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "046006e5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pipeline(steps=[('col_encoder',\n",
      "                 ColumnTransformer(remainder='passthrough', sparse_threshold=0,\n",
      "                                   transformers=[('OHE',\n",
      "                                                  OneHotEncoder(handle_unknown='ignore'),\n",
      "                                                  ['Auction', 'Make', 'Trim',\n",
      "                                                   'WheelType', 'Nationality',\n",
      "                                                   'TopThreeAmericanName',\n",
      "                                                   'VNST'])])),\n",
      "                ('model',\n",
      "                 DecisionTreeClassifier(class_weight='balanced', max_depth=5,\n",
      "                                        random_state=42))])\n",
      "0.2835253358504266\n"
     ]
    }
   ],
   "source": [
    "# decision tree\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "\n",
    "model_dt = DecisionTreeClassifier(class_weight=\"balanced\", random_state=42)\n",
    "\n",
    "model_pipe_dt = Pipeline([(\"col_encoder\", col_transformer),\n",
    "                          (\"model\", model_dt)])\n",
    "\n",
    "search_grid_dt = {\"model__max_depth\": range(1, 10)}\n",
    "\n",
    "grid_model_dt = GridSearchCV(estimator=model_pipe_dt,\n",
    "                             param_grid=search_grid_dt,\n",
    "                             cv=5,\n",
    "                             scoring=\"f1\")\n",
    "\n",
    "grid_model_dt.fit(features_train, target_train)\n",
    "\n",
    "print(grid_model_dt.best_estimator_)\n",
    "print(grid_model_dt.best_score_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "cfe28d66",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.93      0.58      0.71     12846\n",
      "           1       0.18      0.66      0.28      1746\n",
      "\n",
      "    accuracy                           0.59     14592\n",
      "   macro avg       0.55      0.62      0.50     14592\n",
      "weighted avg       0.84      0.59      0.66     14592\n",
      "\n"
     ]
    }
   ],
   "source": [
    "target_test_pred = grid_model_dt.predict(features_test)\n",
    "print(classification_report(target_test, target_test_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "5afa2137",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.07834145179703708"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# random forest\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "model_rf = RandomForestClassifier(class_weight=\"balanced\", \n",
    "                                  random_state=42,\n",
    "                                  n_jobs=-1)\n",
    "\n",
    "model_pipe_rf = Pipeline([(\"ohe\", col_transformer),\n",
    "                          (\"model\", model_rf)])\n",
    "\n",
    "model_pipe_rf.fit(features_train, target_train)\n",
    "\n",
    "cross_val_score(estimator=model_pipe_rf,\n",
    "                X=features_train, \n",
    "                y=target_train, \n",
    "                cv=5, \n",
    "                scoring='f1').mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "d6547d3a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.88      0.99      0.93     12846\n",
      "           1       0.35      0.05      0.09      1746\n",
      "\n",
      "    accuracy                           0.88     14592\n",
      "   macro avg       0.62      0.52      0.51     14592\n",
      "weighted avg       0.82      0.88      0.83     14592\n",
      "\n"
     ]
    }
   ],
   "source": [
    "target_test_pred = model_pipe_rf.predict(features_test)\n",
    "print(classification_report(target_test, target_test_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88f1a839",
   "metadata": {},
   "source": [
    "# Model selection and predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d1206d1",
   "metadata": {},
   "source": [
    "selecting model with best f1 score on test set (mostly bad f1 scores due to low precision)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "2dc7ac30",
   "metadata": {},
   "outputs": [],
   "source": [
    "# predictions on aim data\n",
    "df_aim = pd.read_csv(\"test.csv\")\n",
    "target_aim_pred = grid_model_lr.predict(features_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "6563e541",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    8922\n",
       "1    5670\n",
       "dtype: int64"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# amount of cars that are good buys (0) or \"lemons\" (1) \n",
    "pd.Series(target_aim_pred).value_counts()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}