experimentos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gradient Boosting\n",
    "\n",
    "Otro método de ensamble....\n",
    "\n",
    "\n",
    "Primero importamos todo lo que vamos a necesitar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline \n",
    "import matplotlib.pylab as plt \n",
    "import numpy as np \n",
    "from scipy import sparse\n",
    "from sklearn.model_selection import train_test_split, ShuffleSplit , learning_curve, GridSearchCV\n",
    "from sklearn import metrics \n",
    "from sklearn.ensemble import GradientBoostingRegressor \n",
    "from pprint import pprint \n",
    "import pandas as pd \n",
    "import seaborn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Primero leemos los datos y dividimos la muestra en entrenamiento y prueba."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train = pd.read_csv(\"data/train_preprocesado.csv\")\n",
    "#por alguna razón quedaron dos Na en BsmtCond, así los quitamos pero en realidad hay que regresar a ver qué pasó\n",
    "df_train.dropna(inplace=True)\n",
    "# separamos en entrenamiento y validación\n",
    "train, test = train_test_split(df_train, test_size=0.2)\n",
    "# creamos dataframes para las variables y el objetivo\n",
    "Y_train = train['SalePrice']\n",
    "X_train = train.drop(['SalePrice','Id', 'Unnamed: 0'], axis=1)\n",
    "Y_test = test['SalePrice']\n",
    "X_test = test.drop(['SalePrice','Id', 'Unnamed: 0'], axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos a ajustar los hiperparámetros del método haciendo validación cruzada. Por convenciencia, podemos empaquetar el proceso en una función para poder reutilizarlo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gbCv(X, Y, param_grid, n_jobs):\n",
    "    estimator = GradientBoostingRegressor()\n",
    "    cv = ShuffleSplit(n_splits=3, test_size=0.2)\n",
    "    regressor = GridSearchCV(estimator=estimator, cv=cv, param_grid=param_grid, n_jobs=n_jobs, verbose = 2)\n",
    "    regressor.fit(X,Y)\n",
    "    return cv, regressor.best_estimator_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora vamos a usar la función para estimar los hiperparámetros del método"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 3 folds for each of 1440 candidates, totalling 4320 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=-1)]: Using backend LokyBackend with 8 concurrent workers.\n",
      "[Parallel(n_jobs=-1)]: Done  25 tasks      | elapsed:    6.7s\n",
      "[Parallel(n_jobs=-1)]: Done 146 tasks      | elapsed:   48.7s\n",
      "[Parallel(n_jobs=-1)]: Done 349 tasks      | elapsed:  3.7min\n",
      "[Parallel(n_jobs=-1)]: Done 632 tasks      | elapsed: 10.1min\n",
      "[Parallel(n_jobs=-1)]: Done 997 tasks      | elapsed: 21.9min\n",
      "[Parallel(n_jobs=-1)]: Done 1442 tasks      | elapsed: 30.9min\n",
      "[Parallel(n_jobs=-1)]: Done 1969 tasks      | elapsed: 40.5min\n",
      "[Parallel(n_jobs=-1)]: Done 2576 tasks      | elapsed: 48.4min\n",
      "[Parallel(n_jobs=-1)]: Done 3265 tasks      | elapsed: 55.7min\n",
      "[Parallel(n_jobs=-1)]: Done 4034 tasks      | elapsed: 63.3min\n",
      "[Parallel(n_jobs=-1)]: Done 4320 out of 4320 | elapsed: 65.7min finished\n"
     ]
    }
   ],
   "source": [
    "param_grid = {\n",
    "    'n_estimators': [int(x) for x in np.linspace(start = 200, stop = 2000, num = 10)],\n",
    "    'learning_rate': [0.02, 0.05, 0.1, 0.12],\n",
    "    'max_depth': [4, 6, 10, 15],\n",
    "    'min_samples_leaf': [1, 2, 4],\n",
    "    'max_features': [0.1, 0.3, 1.0]\n",
    "}\n",
    "\n",
    "cv, best_estimator = gbCv(X_train, Y_train, param_grid, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos ver los resultados que obtuvimos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'alpha': 0.9,\n",
       " 'criterion': 'friedman_mse',\n",
       " 'init': None,\n",
       " 'learning_rate': 0.02,\n",
       " 'loss': 'ls',\n",
       " 'max_depth': 4,\n",
       " 'max_features': 0.1,\n",
       " 'max_leaf_nodes': None,\n",
       " 'min_impurity_decrease': 0.0,\n",
       " 'min_impurity_split': None,\n",
       " 'min_samples_leaf': 1,\n",
       " 'min_samples_split': 2,\n",
       " 'min_weight_fraction_leaf': 0.0,\n",
       " 'n_estimators': 2000,\n",
       " 'n_iter_no_change': None,\n",
       " 'presort': 'auto',\n",
       " 'random_state': None,\n",
       " 'subsample': 1.0,\n",
       " 'tol': 0.0001,\n",
       " 'validation_fraction': 0.1,\n",
       " 'verbose': 0,\n",
       " 'warm_start': False}"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "best_estimator.get_params()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y, por su puesto, comparar el score ($R^2$) entre las muestras de entrenamiento y velidación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El score sobre la muestra de entrenamiento es. 0.976762\n",
      "El score sobre la muestra de prueba es. 0.978132\n"
     ]
    }
   ],
   "source": [
    "print(\"El score sobre la muestra de entrenamiento es. {:4f}\".format(best_estimator.score(X_train, Y_train)))\n",
    "print(\"El score sobre la muestra de prueba es. {:4f}\".format(best_estimator.score(X_test, Y_test)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora sí, exportamos el resultado "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_df = pd.read_csv(\"data/test_preprocesado.csv\")\n",
    "X_test = test_df.drop(['Id'], axis=1)\n",
    "result = best_estimator.predict(X_test)\n",
    "result_df = pd.DataFrame(result)\n",
    "result_df.columns = ['SalePrice']\n",
    "result_df = result_df.join(test_df['Id'])\n",
    "result_df['SalePrice'] = np.exp(result_df['SalePrice'])\n",
    "result_df.to_csv(\"data/result_base2.csv\", index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y guardamos el modelo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['data/models/baseline_GB.joblib']"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from joblib import dump, load\n",
    "dump(best_estimator, 'data/models/baseline_GB.joblib')"
   ]
  }
 ],
 "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": 4
}