kaggle-intermediate-machine-learning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9fc7ac30-e095-43fd-bd4a-88ce2e18afdf",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# Imports and CSVs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c1b77974-6b73-491a-b301-4266e16ff557",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import mean_absolute_error\n",
    "from sklearn.impute import SimpleImputer\n",
    "from sklearn.preprocessing import OrdinalEncoder\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.compose import ColumnTransformer\n",
    "from sklearn.pipeline import Pipeline\n",
    "from sklearn.pipeline import make_pipeline\n",
    "from sklearn.model_selection import cross_val_score\n",
    "from xgboost import XGBRegressor\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "43b8efc0-d6b5-495d-affc-05fe9f18d475",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data():\n",
    "    X_full = pd.read_csv('data/kaggle/courses/train.csv', index_col='Id')\n",
    "    X_test_full = pd.read_csv('data/kaggle/courses/test.csv', index_col='Id')\n",
    "    return X_full, X_test_full"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd865145-ecfc-479e-b678-5f7989b3a9a3",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "source": [
    "# Introduction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "08302216-e4bc-49ba-84a1-89e7d8334530",
   "metadata": {
    "editable": true,
    "slideshow": {
     "slide_type": ""
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model 3 MAE: \t23528\n",
      "Model 5 MAE: \t23706\n",
      "Model 0 MAE: \t23740\n",
      "Model 2 MAE: \t23740\n",
      "Model 4 MAE: \t23996\n",
      "Model 1 MAE: \t24015\n"
     ]
    }
   ],
   "source": [
    "X_full, X_test_full = get_data()\n",
    "\n",
    "y = X_full.SalePrice\n",
    "features = ['LotArea', 'YearBuilt', '1stFlrSF', '2ndFlrSF', 'FullBath', 'BedroomAbvGr', 'TotRmsAbvGrd']\n",
    "X = X_full[features].copy()\n",
    "X_test = X_test_full[features].copy()\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(X, y, train_size=0.8, test_size=0.2, random_state=0)\n",
    "\n",
    "model_0 = RandomForestRegressor(random_state=0)\n",
    "model_1 = RandomForestRegressor(n_estimators=50, random_state=0)\n",
    "model_2 = RandomForestRegressor(n_estimators=100, random_state=0)\n",
    "model_3 = RandomForestRegressor(n_estimators=100, criterion='absolute_error', random_state=0)\n",
    "model_4 = RandomForestRegressor(n_estimators=200, min_samples_split=20, random_state=0)\n",
    "model_5 = RandomForestRegressor(n_estimators=100, max_depth=7, random_state=0)\n",
    "models = [model_0, model_1, model_2, model_3, model_4, model_5]\n",
    "\n",
    "def score_model(model, X_t=X_train, X_v=X_valid, y_t=y_train, y_v=y_valid):\n",
    "    model.fit(X_t, y_t)\n",
    "    preds = model.predict(X_v)\n",
    "    return mean_absolute_error(y_v, preds)\n",
    "\n",
    "results = []\n",
    "for i in range(0, len(models)):\n",
    "    mae = score_model(models[i])\n",
    "    result = {f'Model {i}':int(mae)}\n",
    "    results.append(result)\n",
    "# results = dict(zip(models_names, maes))\n",
    "sorted_results = sorted(results, key=lambda x: list(x.values())[0])\n",
    "for result in sorted_results:\n",
    "    model, number = list(result.items())[0]\n",
    "    print(f\"{model} MAE: \\t{number}\")\n",
    "\n",
    "# my_model = RandomForestRegressor(random_state=0)\n",
    "# my_model.fit(X, y)\n",
    "# preds_test = my_model.predict(X_test)\n",
    "# output = pd.DataFrame({'Id': X_test.index, 'SalePrice': preds_test})\n",
    "# output.to_csv('submission.csv', index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2f52c4c-2748-4dc5-b7a7-d92a89aeeda8",
   "metadata": {},
   "source": [
    "# Missing Values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36a566d3-a672-436c-8e8b-d8c8bee90b30",
   "metadata": {},
   "source": [
    "## Lesson"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "880d4105-6c4a-4312-bb53-b0aed59e6d4e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE (drop columns with missing values):\t17837\n",
      "MAE (imputation):\t\t\t18062\n"
     ]
    }
   ],
   "source": [
    "X_full, X_test_full = get_data()\n",
    "\n",
    "X_full.dropna(axis=0, subset=['SalePrice'], inplace=True)\n",
    "y = X_full.SalePrice\n",
    "X_full.drop(['SalePrice'], axis=1, inplace=True)\n",
    "X = X_full.select_dtypes(exclude=['object'])\n",
    "X_test = X_test_full.select_dtypes(exclude=['object'])\n",
    "\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(X, y, train_size=0.8, test_size=0.2, random_state=0)\n",
    "\n",
    "missing_val_count_by_column = (X_train.isnull().sum())\n",
    "percentage_missing = missing_val_count_by_column / X_train.shape[0] * 100\n",
    "# print(percentage_missing[percentage_missing > 0]) # if low, dropping is usually bad\n",
    "\n",
    "def score_dataset(X_train, X_valid, y_train, y_valid):\n",
    "    model = RandomForestRegressor(n_estimators=100, random_state=0)\n",
    "    model.fit(X_train, y_train)\n",
    "    preds = model.predict(X_valid)\n",
    "    return mean_absolute_error(y_valid, preds)\n",
    "\n",
    "cols_with_missing = [col for col in X_train.columns if X_train[col].isnull().any()] # if any null values in col\n",
    "reduced_X_train = X_train.drop(cols_with_missing, axis=1)\n",
    "reduced_X_valid = X_valid.drop(cols_with_missing, axis=1)\n",
    "print(f\"MAE (drop columns with missing values):\\t{int(score_dataset(reduced_X_train, reduced_X_valid, y_train, y_valid))}\")\n",
    "\n",
    "my_imputer = SimpleImputer()\n",
    "imputed_X_train = pd.DataFrame(my_imputer.fit_transform(X_train)) # only fit once\n",
    "imputed_X_valid = pd.DataFrame(my_imputer.transform(X_valid))\n",
    "imputed_X_train.columns = X_train.columns\n",
    "imputed_X_valid.columns = X_valid.columns\n",
    "\n",
    "print(f\"MAE (imputation):\\t\\t\\t{int(score_dataset(imputed_X_train, imputed_X_valid, y_train, y_valid))}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d425fd5-4eee-44f8-98ee-da78e9aa7eef",
   "metadata": {},
   "source": [
    "## Mine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f3367336-42ea-468f-a30d-0de2f6b8a98d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE (drop GarageYrBlt then impute): 17929\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\jgibb\\.pyenv\\pyenv-win\\versions\\3.12.5\\Lib\\site-packages\\sklearn\\base.py:493: UserWarning: X does not have valid feature names, but RandomForestRegressor was fitted with feature names\n",
      "  warnings.warn(\n"
     ]
    }
   ],
   "source": [
    "X_full, X_test_full = get_data()\n",
    "\n",
    "X_full.dropna(axis=0, subset=['SalePrice'], inplace=True)\n",
    "y = X_full.SalePrice\n",
    "X_full.drop(['SalePrice'], axis=1, inplace=True)\n",
    "X = X_full.select_dtypes(exclude=['object'])\n",
    "X_test = X_test_full.select_dtypes(exclude=['object'])\n",
    "\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(X, y, train_size=0.8, test_size=0.2, random_state=0)\n",
    "\n",
    "X_train_post_drop = X_train.drop(['GarageYrBlt'], axis=1)\n",
    "X_valid_post_drop = X_valid.drop(['GarageYrBlt'], axis=1)\n",
    "X_test_post_drop = X_test.drop(['GarageYrBlt'], axis=1)\n",
    "\n",
    "my_imputer = SimpleImputer(strategy='median')\n",
    "imputed_X_train = pd.DataFrame(my_imputer.fit_transform(X_train_post_drop))\n",
    "imputed_X_valid = pd.DataFrame(my_imputer.transform(X_valid_post_drop))\n",
    "imputed_X_train.columns = X_train_post_drop.columns\n",
    "imputed_X_valid.columns = X_valid_post_drop.columns\n",
    "\n",
    "final_X_train = imputed_X_train\n",
    "final_X_valid = imputed_X_valid\n",
    "\n",
    "model = RandomForestRegressor(n_estimators=100, random_state=0)\n",
    "model.fit(final_X_train, y_train)\n",
    "\n",
    "preds_valid = model.predict(final_X_valid)\n",
    "print(f\"MAE (drop GarageYrBlt then impute): {int(mean_absolute_error(y_valid, preds_valid))}\")\n",
    "\n",
    "final_X_test = pd.DataFrame(my_imputer.transform(X_test_post_drop))\n",
    "preds_test = model.predict(final_X_test)\n",
    "X_test_full[\"Predictions\"] = preds_test"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abac31ba-59a9-4ba5-a870-c1d12610b9a3",
   "metadata": {},
   "source": [
    "# Categorical Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f1321306-a85a-4838-8d8a-b83548bdc42d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE from Approach 1 (Drop categorical variables): 17837\n",
      "MAE from Approach 2 (Ordinal Encoding): 16988\n",
      "MAE from Approach 3 (One-Hot Encoding): 17358\n"
     ]
    }
   ],
   "source": [
    "# X = pd.read_csv('train.csv', index_col='Id')\n",
    "# X_test = pd.read_csv('test.csv', index_col='Id')\n",
    "X_full, X_test_full = get_data()\n",
    "\n",
    "X_full.dropna(axis=0, subset=['SalePrice'], inplace=True)\n",
    "y = X_full.SalePrice\n",
    "X_full.drop(['SalePrice'], axis=1, inplace=True)\n",
    "cols_with_missing = [col for col in X.columns if X[col].isnull().any()] \n",
    "X_full.drop(cols_with_missing, axis=1, inplace=True)\n",
    "X_test_full.drop(cols_with_missing, axis=1, inplace=True)\n",
    "\n",
    "X_train, X_valid, y_train, y_valid = train_test_split(X_full, y, train_size=0.8, test_size=0.2, random_state=0)\n",
    "\n",
    "def score_dataset(X_train, X_valid, y_train, y_valid):\n",
    "    model = RandomForestRegressor(n_estimators=100, random_state=0)\n",
    "    model.fit(X_train, y_train)\n",
    "    preds = model.predict(X_valid)\n",
    "    return mean_absolute_error(y_valid, preds)\n",
    "\n",
    "drop_X_train = X_train.select_dtypes(exclude=['object']) # drop categorical data\n",
    "drop_X_valid = X_valid.select_dtypes(exclude=['object'])\n",
    "print(f\"MAE from Approach 1 (Drop categorical variables): {int(score_dataset(drop_X_train, drop_X_valid, y_train, y_valid))}\")\n",
    "\n",
    "object_cols = [col for col in X_train.columns if X_train[col].dtype == \"object\"]\n",
    "good_label_cols = [col for col in object_cols if set(X_valid[col]).issubset(set(X_train[col]))] # if col in train and valid\n",
    "bad_label_cols = list(set(object_cols)-set(good_label_cols)) # if col in train but not valid\n",
    "# print('Categorical columns that will be ordinal encoded:', good_label_cols)\n",
    "# print('\\nCategorical columns that will be dropped from the dataset:', bad_label_cols)\n",
    "\n",
    "label_X_train = X_train.drop(bad_label_cols, axis=1)\n",
    "label_X_valid = X_valid.drop(bad_label_cols, axis=1)\n",
    "ordinal_encoder = OrdinalEncoder()\n",
    "label_X_train[good_label_cols] = ordinal_encoder.fit_transform(X_train[good_label_cols])\n",
    "label_X_valid[good_label_cols] = ordinal_encoder.transform(X_valid[good_label_cols])\n",
    "print(f\"MAE from Approach 2 (Ordinal Encoding): {int(score_dataset(label_X_train, label_X_valid, y_train, y_valid))}\") \n",
    "\n",
    "# object_nunique = list(map(lambda col: X_train[col].nunique(), object_cols))\n",
    "# d = dict(zip(object_cols, object_nunique))\n",
    "# sorted(d.items(), key=lambda x: x[1], reverse=True) # sorts by the values not the keys; [1] is the second value, i.e. the count\n",
    "low_cardinality_cols = [col for col in object_cols if X_train[col].nunique() < 10]\n",
    "high_cardinality_cols = list(set(object_cols)-set(low_cardinality_cols))\n",
    "# print('Categorical columns that will be one-hot encoded:', low_cardinality_cols)\n",
    "# print('\\nCategorical columns that will be dropped from the dataset:', high_cardinality_cols)\n",
    "\n",
    "OH_encoder = OneHotEncoder(handle_unknown='ignore', sparse_output=False)\n",
    "OH_cols_train = pd.DataFrame(OH_encoder.fit_transform(X_train[low_cardinality_cols])) # only low-card cols\n",
    "OH_cols_valid = pd.DataFrame(OH_encoder.transform(X_valid[low_cardinality_cols]))\n",
    "OH_cols_train.index = X_train.index # re-add index\n",
    "OH_cols_valid.index = X_valid.index\n",
    "num_X_train = X_train.drop(object_cols, axis=1) # remove non-numerical columns\n",
    "num_X_valid = X_valid.drop(object_cols, axis=1)\n",
    "OH_X_train = pd.concat([num_X_train, OH_cols_train], axis=1)\n",
    "OH_X_valid = pd.concat([num_X_valid, OH_cols_valid], axis=1)\n",
    "OH_X_train.columns = OH_X_train.columns.astype(str)\n",
    "OH_X_valid.columns = OH_X_valid.columns.astype(str)\n",
    "print(f\"MAE from Approach 3 (One-Hot Encoding): {int(score_dataset(OH_X_train, OH_X_valid, y_train, y_valid))}\") "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "281ec25e-3c45-4c4b-bc59-2aa9b1e803de",
   "metadata": {},
   "source": [
    "# Pipelines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8342919c-d251-408f-9f77-468a7b901ce0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MAE: 17540\n"
     ]
    }
   ],
   "source": [
    "X_full, X_test_full = get_data()\n",
    "\n",
    "X_full.dropna(axis=0, subset=['SalePrice'], inplace=True)\n",
    "y = X_full.SalePrice\n",
    "X_full.drop(['SalePrice'], axis=1, inplace=True)\n",
    "\n",
    "X_train_full, X_valid_full, y_train, y_valid = train_test_split(X_full, y, train_size=0.8, test_size=0.2, random_state=0)\n",
    "\n",
    "categorical_cols = [cname for cname in X_train_full.columns\n",
    "                    if X_train_full[cname].nunique() < 10\n",
    "                    and X_train_full[cname].dtype == \"object\"]\n",
    "numerical_cols = [cname for cname in X_train_full.columns\n",
    "                  if X_train_full[cname].dtype in ['int64', 'float64']]\n",
    "my_cols = categorical_cols + numerical_cols\n",
    "X_train = X_train_full[my_cols].copy()\n",
    "X_valid = X_valid_full[my_cols].copy()\n",
    "X_test = X_test_full[my_cols].copy()\n",
    "\n",
    "numerical_transformer = SimpleImputer(strategy='constant')\n",
    "\n",
    "categorical_transformer = Pipeline(steps=[\n",
    "    ('imputer', SimpleImputer(strategy='constant')), # strategy='most_frequent'\n",
    "    ('onehot', OneHotEncoder(handle_unknown='ignore'))\n",
    "])\n",
    "\n",
    "preprocessor = ColumnTransformer(\n",
    "    transformers=[\n",
    "        ('num', numerical_transformer, numerical_cols),\n",
    "        ('cat', categorical_transformer, categorical_cols)\n",
    "    ])\n",
    "\n",
    "model = RandomForestRegressor(n_estimators=100, random_state=0)\n",
    "\n",
    "clf = Pipeline(steps=[('preprocessor', preprocessor), # clf means classifier\n",
    "                      ('model', model)])\n",
    "clf.fit(X_train, y_train)\n",
    "preds = clf.predict(X_valid)\n",
    "print(f'MAE: {int(mean_absolute_error(y_valid, preds))}')\n",
    "\n",
    "preds_test = clf.predict(X_test)\n",
    "X_test_full[\"Predictions\"] = preds_test"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a6212b0-d949-4209-a4ca-9fc01cedeefd",
   "metadata": {},
   "source": [
    "# Cross-Validation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "896c539e-2345-4f3d-8611-27e6a28c36ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50: 18353.8393511688\n",
      "100: 18395.2151680032\n",
      "150: 18288.730020956387\n",
      "200: 18248.345889801505\n",
      "250: 18255.26922247291\n",
      "300: 18275.241922621914\n",
      "350: 18270.29183308043\n",
      "400: 18270.197974402367\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "X_full, X_test_full = get_data()\n",
    "\n",
    "X_full.dropna(axis=0, subset=['SalePrice'], inplace=True)\n",
    "y = X_full.SalePrice              \n",
    "X_full.drop(['SalePrice'], axis=1, inplace=True)\n",
    "numeric_cols = [cname for cname in X_full.columns if X_full[cname].dtype in ['int64', 'float64']]\n",
    "X = X_full[numeric_cols].copy()\n",
    "X_test_full = X_test_full[numeric_cols].copy()\n",
    "\n",
    "def get_score(n_estimators, folds):\n",
    "    my_pipeline = Pipeline(steps=[\n",
    "        ('preprocessor', SimpleImputer()),\n",
    "        ('model', RandomForestRegressor(n_estimators=n_estimators, random_state=0))\n",
    "    ])\n",
    "\n",
    "    scores = -1 * cross_val_score(my_pipeline, X, y, # *-1 since sklearn calculates *negative* MAE\n",
    "                                  cv=folds,\n",
    "                                  scoring='neg_mean_absolute_error')\n",
    "    return scores.mean()\n",
    "\n",
    "results = {}\n",
    "for i in range(50,401,50):\n",
    "    results[i] = get_score(i,3)\n",
    "    print(f'{i}: {results[i]}')\n",
    "\n",
    "plt.plot(list(results.keys()), list(results.values()))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59c6f0f5-ae1e-41b3-87ab-0ce189de787c",
   "metadata": {},
   "source": [
    "# XGBoost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "756408e5-e3ab-4624-b4f6-38346a8f1982",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Absolute Error: 17032.769063035103\n"
     ]
    }
   ],
   "source": [
    "X, X_test_full = get_data()\n",
    "\n",
    "X.dropna(axis=0, subset=['SalePrice'], inplace=True)\n",
    "y = X.SalePrice              \n",
    "X.drop(['SalePrice'], axis=1, inplace=True)\n",
    "X_train_full, X_valid_full, y_train, y_valid = train_test_split(X, y, train_size=0.8, test_size=0.2,\n",
    "                                                                random_state=0)\n",
    "\n",
    "low_cardinality_cols = [cname for cname in X_train_full.columns if X_train_full[cname].nunique() < 10 and \n",
    "                        X_train_full[cname].dtype == \"object\"]\n",
    "numeric_cols = [cname for cname in X_train_full.columns if X_train_full[cname].dtype in ['int64', 'float64']]\n",
    "my_cols = low_cardinality_cols + numeric_cols\n",
    "X_train = X_train_full[my_cols].copy()\n",
    "X_valid = X_valid_full[my_cols].copy()\n",
    "X_test = X_test_full[my_cols].copy()\n",
    "\n",
    "X_train = pd.get_dummies(X_train)\n",
    "X_valid = pd.get_dummies(X_valid)\n",
    "X_test = pd.get_dummies(X_test)\n",
    "X_train, X_valid = X_train.align(X_valid, join='left', axis=1)\n",
    "X_train, X_test = X_train.align(X_test, join='left', axis=1)\n",
    "\n",
    "xgb_model = XGBRegressor(n_estimators=1000, learning_rate=0.05, n_jobs=4, early_stopping_rounds=5)\n",
    "xgb_model.fit(X_train, y_train, \n",
    "             eval_set=[(X_valid, y_valid)], \n",
    "             verbose=False)\n",
    "predictions_xgb = xgb_model.predict(X_valid)\n",
    "mae_xgb = mean_absolute_error(y_valid, predictions_xgb)\n",
    "print(\"Mean Absolute Error:\" , mae_xgb)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e5c8129-3714-4823-a1d1-576a2876fe29",
   "metadata": {},
   "source": [
    "# Data Leakage\n",
    "\n",
    "**Target leakage** occurs when your predictors include data that will not be available at the time you make predictions.\n",
    "\n",
    "**Train-Test Contamination** If your validation is based on a simple train-test split, exclude the validation data from any type of fitting, including the fitting of preprocessing steps. This is easier if you use scikit-learn pipelines."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5ccb26f2-02a6-4c0d-83f9-e47d516a4e04",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of rows in the dataset: 1319\n",
      "Cross-validation accuracy: 0.980294\n",
      "Fraction of those who did not receive a card and had no expenditures: 1.00\n",
      "Fraction of those who received a card and had no expenditures: 0.02\n",
      "Cross-validation accuracy: 0.834716\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv('data/kaggle/courses/AER_credit_card_data.csv', \n",
    "                   true_values = ['yes'], false_values = ['no'])\n",
    "y = data.card\n",
    "X = data.drop(['card'], axis=1)\n",
    "print(\"Number of rows in the dataset:\", X.shape[0])\n",
    "X.head()\n",
    "my_pipeline = make_pipeline(RandomForestClassifier(n_estimators=100))\n",
    "cv_scores = cross_val_score(my_pipeline, X, y, \n",
    "                            cv=5,\n",
    "                            scoring='accuracy')\n",
    "print(\"Cross-validation accuracy: %f\" % cv_scores.mean())\n",
    "#Cross-validation accuracy: 0.981052 -> abnormally high\n",
    "\n",
    "expenditures_cardholders = X.expenditure[y]\n",
    "expenditures_noncardholders = X.expenditure[~y]\n",
    "print('Fraction of those who did not receive a card and had no expenditures: %.2f' \\\n",
    "      %((expenditures_noncardholders == 0).mean()))\n",
    "print('Fraction of those who received a card and had no expenditures: %.2f' \\\n",
    "      %(( expenditures_cardholders == 0).mean()))\n",
    "\n",
    "# No card = no expenditures (logically), so not useful. Also, target leakage: expenditure changes after. Exclude.\n",
    "# share is partially determined by expenditure. Exclude.\n",
    "# active, majorcards sound concerning from the description. Exclude.\n",
    "\n",
    "potential_leaks = ['expenditure', 'share', 'active', 'majorcards']\n",
    "X2 = X.drop(potential_leaks, axis=1)\n",
    "cv_scores = cross_val_score(my_pipeline, X2, y, \n",
    "                            cv=5,\n",
    "                            scoring='accuracy')\n",
    "print(\"Cross-validation accuracy: %f\" % cv_scores.mean())\n",
    "# Cross-validation accuracy: 0.830919 -> more realistic"
   ]
  }
 ],
 "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.12.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}