Regresion-SinReg.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 501
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 1162,
     "status": "ok",
     "timestamp": 1555459153100,
     "user": {
      "displayName": "Matias Gonzalez Fernandez",
      "photoUrl": "",
      "userId": "02925906530158308490"
     },
     "user_tz": 180
    },
    "id": "paHr9FLWuqt7",
    "outputId": "d91d8d43-35e4-434d-ca93-32a9605eb455"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib as mpl\n",
    "from scipy import stats\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from scipy.sparse import hstack\n",
    "from sklearn.linear_model import Ridge\n",
    "from sklearn.model_selection import train_test_split, KFold, cross_val_score\n",
    "from sklearn.linear_model import LinearRegression, Lasso, LassoCV, Ridge, RidgeCV\n",
    "from sklearn.preprocessing import PolynomialFeatures, StandardScaler\n",
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "from sklearn import preprocessing\n",
    "from sklearn.linear_model import ElasticNetCV\n",
    "from sklearn.preprocessing import PolynomialFeatures\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importar pickle con el dataset preprocesado\n",
    "df = pd.read_pickle('DatasetFinalParaEntrenar.pkl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fit & Transform"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Separar Variables por tipo\n",
    "categoricals = ['property_type','place_name','state_name','zona']\n",
    "descriptions = ['texto']\n",
    "numericals = ['surface_total_in_m2', 'surface_covered_in_m2', 'floor', 'rooms', 'expenses','lat','lon']\n",
    "dummies = ['subte','colectivo','balcon','tren','porton','financia', 'parrilla','pileta', 'solarium', 'lavadero', 'estacionamiento', 'no_apto_credito','apto_credito', 'amplioliving', 'cocheras', 'frente', 'contrafrente','seguridad', 'amenities', 'SUM', 'espaciosverdes','jacuzzi','estrenar','aptoprofesional','pozo','categoria','reciclado','luminoso','acondicionado','quincho','escalera']\n",
    "target = ['price_usd_per_m2']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Analyzar DEGREES de posibles polynomial features para una regresión lineal\n",
    "from sklearn.pipeline import make_pipeline\n",
    "#vectorizer = TfidfVectorizer(min_df=5)\n",
    "#enc = DictVectorizer()\n",
    "#clf = LinearRegression(fit_intercept=True)\n",
    "#normalizer = preprocessing.Normalizer()\n",
    "#poly = PolynomialFeatures(degree), include_bias = False)\n",
    "\n",
    "def PolynomialRegression(degree=4, **kwargs):\n",
    "    return make_pipeline(PolynomialFeatures(degree),\n",
    "                         LinearRegression(fit_intercept=True,n_jobs=-1,**kwargs))\n",
    "\n",
    "from sklearn.model_selection import validation_curve\n",
    "grados_a_testear = np.arange(0, 9)\n",
    "train_score, val_score = validation_curve(PolynomialRegression(), df[numericals], Ydf, 'polynomialfeatures__degree'\n",
    "                                          , grados_a_testear, cv=10) #cv= validacion cruzada, cuanta cantidad quiero\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.         0.         0.         0.         0.         0.\n",
      "  0.         0.         0.         0.        ]\n",
      " [0.21211393 0.21001041 0.21081992 0.20577614 0.20962305 0.21234968\n",
      "  0.2117226  0.2183311  0.21375255 0.20432098]\n",
      " [0.30011578 0.29899187 0.30096051 0.29235834 0.29639803 0.29921609\n",
      "  0.29874804 0.29979044 0.30334968 0.29158386]]\n",
      "[[-1.72927606e-02 -2.13082605e-02 -5.12597618e-03 -6.85153401e-03\n",
      "  -8.14488694e-04 -1.49136775e-05 -3.67340465e-02 -3.29047455e-02\n",
      "  -1.76501696e-03 -7.70378039e-03]\n",
      " [ 1.75088824e-01  1.94051266e-01  2.01667813e-01  2.46377738e-01\n",
      "   2.14502307e-01  1.84636055e-01  1.65049318e-01 -9.58684362e-03\n",
      "   1.68349061e-01  2.59203486e-01]\n",
      " [ 2.60130300e-01  2.35990255e-01  2.70889309e-01  3.42791147e-01\n",
      "   2.85864738e-01  2.80895773e-01  2.62774478e-01 -3.44689772e-01\n",
      "   2.31526873e-01  3.49461252e-01]]\n"
     ]
    },
    {
     "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": [
    "# Graficar curva\n",
    "print(train_score[:3])\n",
    "print(val_score[:3])\n",
    "\n",
    "plt.plot(grados_a_testear, np.mean(train_score, axis=1), color='blue', label='training score')\n",
    "plt.plot(grados_a_testear, np.mean(val_score, axis=1), color='red', label='validation score')\n",
    "plt.legend(loc='best')\n",
    "plt.ylim(0, 1)\n",
    "plt.xlabel('degree')\n",
    "plt.ylabel('score');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Separar Train-Test\n",
    "\n",
    "Xdf = df[np.concatenate([\n",
    "        categoricals,\n",
    "        descriptions,\n",
    "        numericals,\n",
    "        dummies\n",
    "])]\n",
    "Ydf = df[target]\n",
    "\n",
    "X_trainDf, X_testDf, y_trainDf, y_testDf = train_test_split(Xdf, Ydf, test_size=0.30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# FIT (función) - Vectorizar categóricas, Vectorizar texto en Description y Normalizar continuas\n",
    "vectorizer = TfidfVectorizer(min_df=5)\n",
    "enc = DictVectorizer()\n",
    "clf = LinearRegression(fit_intercept=True,n_jobs=-1)\n",
    "normalizer = preprocessing.Normalizer()\n",
    "poly = PolynomialFeatures(degree = 1, include_bias = False)\n",
    "\n",
    "def fit_model(X_train, Y_train):\n",
    "    texts = X_train[descriptions]\n",
    "    texts = texts.applymap(lambda x: x.lower())\n",
    "    texts = texts.replace('[^a-zA-Z0-9]', ' ', regex = True)\n",
    "\n",
    "    X_tfidf = vectorizer.fit_transform(texts[descriptions[0]])\n",
    "    \n",
    "    X_train_categ = enc.fit_transform(X_train[categoricals].to_dict('records'))\n",
    "    \n",
    "    X_numericas = poly.fit_transform(normalizer.fit_transform(X_train[numericals]))\n",
    "    \n",
    "    X_dummies = X_train[dummies]\n",
    "\n",
    "    X = hstack([X_tfidf, X_train_categ, X_numericas, X_dummies]) # regualirzar las numericas luego de splitear\n",
    "    \n",
    "    # train model on data\n",
    "    clf.fit(X, Y_train)\n",
    "    return X, Y_train\n",
    "\n",
    "X__train, y__train = fit_model(X_trainDf, y_trainDf)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<26910x21981 sparse matrix of type '<class 'numpy.float64'>'\n",
       "\twith 2153646 stored elements in COOrdinate format>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# TRANSFORM (función)\n",
    "def transform_model(X_train):\n",
    "    texts = X_train[descriptions]\n",
    "    texts = texts.applymap(lambda x: x.lower())\n",
    "    texts = texts.replace('[^a-zA-Z0-9]', ' ', regex = True)\n",
    "\n",
    "    X_tfidf = vectorizer.transform(texts[descriptions[0]])\n",
    "    \n",
    "    X_train_categ = enc.transform(X_train[categoricals].to_dict('records'))\n",
    "    \n",
    "    X_numericas = poly.transform(normalizer.transform(X_train[numericals]))\n",
    "    \n",
    "    X_dummies = X_train[dummies]\n",
    "\n",
    "    X = hstack([X_tfidf, X_train_categ, X_numericas, X_dummies])\n",
    "    \n",
    "    return X\n",
    "X__test = transform_model(X_testDf)\n",
    "X__test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score de Entrenamiento:  0.8615408971250876\n",
      "Score de Test:  0.5161040948823841\n",
      "MAE:  398.16659930363534\n",
      "MSE:  417246.8499607679\n",
      "RMSE:  645.9464760804628\n",
      "R2:  0.5161040948823841\n"
     ]
    }
   ],
   "source": [
    "# Métricas\n",
    "from sklearn import metrics\n",
    "print ('Score de Entrenamiento: ',clf.score(X__train, y__train))\n",
    "print ('Score de Test: ',clf.score(X__test, y_testDf))\n",
    "print ('MAE: ', metrics.mean_absolute_error(y_testDf, clf.predict(X__test)))\n",
    "print ('MSE: ', metrics.mean_squared_error(y_testDf, clf.predict(X__test)))\n",
    "print ('RMSE: ', np.sqrt(metrics.mean_squared_error(y_testDf, clf.predict(X__test))))\n",
    "print ('R2: ', metrics.r2_score(y_testDf, clf.predict(X__test)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1355.5373251973263\n",
      "1453.4883720930234\n"
     ]
    }
   ],
   "source": [
    "# Ejemplo\n",
    "print(clf.predict(X__test)[100][0])\n",
    "print(y_testDf.iloc[100,0])"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "ProperatyExploracion.ipynb",
   "provenance": [],
   "version": "0.3.2"
  },
  "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}