ModelEconomics.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import findspark\n",
    "findspark.init('/home/sdmohant/spark-3.0.0-bin-hadoop2.7')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyspark\n",
    "from pyspark import SparkContext,SparkConf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql import SparkSession"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/sdmohant/spark-3.0.0-bin-hadoop2.7/python/pyspark/context.py:220: DeprecationWarning: Support for Python 2 and Python 3 prior to version 3.6 is deprecated as of Spark 3.0. See also the plan for dropping Python 2 support at https://spark.apache.org/news/plan-for-dropping-python-2-support.html.\n",
      "  DeprecationWarning)\n"
     ]
    }
   ],
   "source": [
    "#spark = SparkSession.builder.appName(\"MyApp\").getOrCreate()\n",
    "#spark = SparkSession.builder.appName(\"MyName\").getOrCreate()\n",
    "conf = SparkConf().set(\"spark.cores.max\", \"16\") \\\n",
    "    .set(\"spark.driver.memory\", \"16g\") \\\n",
    "    .set(\"spark.executor.memory\", \"16g\") \\\n",
    "    .set(\"spark.executor.memory_overhead\", \"16g\") \\\n",
    "    .set(\"spark.driver.maxResultsSize\", \"0\") \\\n",
    "    .set(\"spark.sql.shuffle.partitions\",\"300\")\n",
    "\n",
    "sc = SparkContext(appName=\"economicsmodel\", conf=conf)\n",
    "spark = SparkSession(sc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql.functions import isnan, count, col, when"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "economicsFOSID = spark.read.options(header = True, inferSchema = True,delimiter=',').csv(\"FOSDomains.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "economicsFOSID = economicsFOSID.filter(economicsFOSID[\"Domain\"]==\"Economics\").collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "547"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(economicsFOSID)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "papers = spark.read.options(header = True, inferSchema = True,delimiter=',').csv(\"AllPapersFOS1.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyspark.sql.types import ArrayType, StructField, StructType, StringType, IntegerType,LongType"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "schema = StructType([\n",
    "    StructField('FOS_ID', LongType(), True),\n",
    "    StructField('Domain', StringType(), True)\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert list to RDD\n",
    "rdd = spark.sparkContext.parallelize(economicsFOSID)\n",
    "\n",
    "# Create data frame\n",
    "fos = spark.createDataFrame(rdd,schema)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+---------+---------+\n",
      "|   FOS_ID|   Domain|\n",
      "+---------+---------+\n",
      "|112930515|Economics|\n",
      "|149923435|Economics|\n",
      "+---------+---------+\n",
      "only showing top 2 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "fos.show(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "papers_filtered = papers.join(fos,on=\"FOS_ID\",how=\"inner\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10870691"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "papers_filtered.count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "papers_filtered = papers_filtered.withColumnRenamed(\"CitationCount\",\"label\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['FOS_ID',\n",
       " 'PaperID',\n",
       " 'Rank',\n",
       " 'PaperYear',\n",
       " 'Volume',\n",
       " 'Issue',\n",
       " 'ReferenceCount',\n",
       " 'label',\n",
       " 'EstimatedCount',\n",
       " 'PaperAge',\n",
       " 'IsJournal',\n",
       " 'min_FOSRank',\n",
       " 'max_FOSRank',\n",
       " 'max_FOSPaperCount',\n",
       " 'min_FOSPaperCount',\n",
       " 'min_FOSCitationCount',\n",
       " 'max_FOSCitationCount',\n",
       " 'PaperRefCnt',\n",
       " 'Domain']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "papers_filtered.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "papers_filtered1 = papers_filtered.select([\"PaperID\",\"EstimatedCount\",\"Rank\",\"ReferenceCount\",\"PaperAge\",\\\n",
    "                        \"IsJournal\",\"min_FOSRank\",\"max_FOSRank\",\"max_FOSPaperCount\",\"min_FOSPaperCount\",\"min_FOSCitationCount\",\\\n",
    "                        \"max_FOSCitationCount\",\"PaperRefCnt\",\"label\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "(sample1,sample2) = papers_filtered1.randomSplit([0.1,0.8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1208229"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample1.count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import model_selection\n",
    "from sklearn.model_selection import KFold "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------+\n",
      "|EstimatedCount|\n",
      "+--------------+\n",
      "|             0|\n",
      "|             0|\n",
      "|             0|\n",
      "|             0|\n",
      "+--------------+\n",
      "only showing top 4 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "papers_filtered1.select([\"EstimatedCount\"]).show(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample1_pd = sample1.toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_est = np.array(sample1_pd[\"EstimatedCount\"])\n",
    "y_act = np.array(sample1_pd[\"label\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparison with Microsoft Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean Absolute Error of EstimatedCount:', 2.7421060080497983)\n",
      "('Mean Squared Error of EstimatedCount:', 6616.035691909398)\n",
      "('Root Mean Squared of with EstimatedCount:', 81.33901703309057)\n"
     ]
    }
   ],
   "source": [
    "print('Mean Absolute Error of EstimatedCount:', metrics.mean_absolute_error(y_act, y_est))\n",
    "print('Mean Squared Error of EstimatedCount:', metrics.mean_squared_error(y_act, y_est))\n",
    "print('Root Mean Squared of with EstimatedCount:', np.sqrt(metrics.mean_squared_error(y_act, y_est)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample1_pd = sample1_pd.drop([\"PaperID\",\"EstimatedCount\"],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = sample1_pd.iloc[:, 0:11].values\n",
    "y = sample1_pd.iloc[:, 11].values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random Forest Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import KFold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kf = KFold(n_splits=5)\n",
    "kf.get_n_splits(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean Absolute Error:', 2.1662770407097827)\n",
      "('Mean Squared Error:', 453.94763333626565)\n",
      "('Root Mean Squared Error:', 21.30604687257272)\n",
      "('Mean Absolute Error:', 1.8668518542783668)\n",
      "('Mean Squared Error:', 351.95687287613396)\n",
      "('Root Mean Squared Error:', 18.760513662374333)\n",
      "('Mean Absolute Error:', 2.1577870658065277)\n",
      "('Mean Squared Error:', 1134.1335768252964)\n",
      "('Root Mean Squared Error:', 33.67689975079797)\n",
      "('Mean Absolute Error:', 2.1278270016450977)\n",
      "('Mean Squared Error:', 571.0568509948524)\n",
      "('Root Mean Squared Error:', 23.896795831132934)\n",
      "('Mean Absolute Error:', 1.4596697850960192)\n",
      "('Mean Squared Error:', 1066.8760539278367)\n",
      "('Root Mean Squared Error:', 32.66306865448861)\n"
     ]
    }
   ],
   "source": [
    "rmse_list = []\n",
    "for train_index, test_index in kf.split(X,y):\n",
    "    #print(\"TRAIN:\", train_index, \"TEST:\", test_index)\n",
    "    X_train, X_test = X[train_index], X[test_index]\n",
    "    y_train, y_test = y[train_index], y[test_index]\n",
    "    #print(\"X_train:\", len(X_train), \"X_test:\", len(X_test))\n",
    "    #print(\"y_train:\", len(y_train), \"y_test:\", len(y_test))\n",
    "    regressor = RandomForestRegressor(n_estimators=100, max_depth=30, random_state=0)\n",
    "    regressor.fit(X_train, y_train)\n",
    "    y_pred = regressor.predict(X_test)\n",
    "    rmse_list.append(np.sqrt(metrics.mean_squared_error(y_test, y_pred)))\n",
    "    print('Mean Absolute Error:', metrics.mean_absolute_error(y_test, y_pred))\n",
    "    print('Mean Squared Error:', metrics.mean_squared_error(y_test, y_pred))\n",
    "    print('Root Mean Squared Error:', np.sqrt(metrics.mean_squared_error(y_test, y_pred)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean RMSE is :', 26.060664954273314)\n"
     ]
    }
   ],
   "source": [
    "rmse_sum = 0\n",
    "for index in range(0,5):\n",
    "    rmse_sum = rmse_sum + rmse_list[index]\n",
    "mean_rmse = rmse_sum/5\n",
    "print(\"Mean RMSE is :\",mean_rmse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "featureslist=sample1_pd.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "importances = regressor.feature_importances_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f7257448210>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "(pd.Series(importances, index=featureslist[0:11]).plot(kind='barh')) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## XGBoost Regression model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "import xgboost as xgb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kf = KFold(n_splits=5)\n",
    "kf.get_n_splits(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('TRAIN:', array([ 241646,  241647,  241648, ..., 1208226, 1208227, 1208228]), 'TEST:', array([     0,      1,      2, ..., 241643, 241644, 241645]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 2.3493951726956586)\n",
      "('Mean Squared Error of XGBoost Kfold:', 1408.6801153359768)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 37.532387551766234)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 1208226, 1208227, 1208228]), 'TEST:', array([241646, 241647, 241648, ..., 483289, 483290, 483291]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 2.0142226205752722)\n",
      "('Mean Squared Error of XGBoost Kfold:', 824.6155012686721)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 28.716119188857537)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 1208226, 1208227, 1208228]), 'TEST:', array([483292, 483293, 483294, ..., 724935, 724936, 724937]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 2.2489712748061397)\n",
      "('Mean Squared Error of XGBoost Kfold:', 1124.5726758421004)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 33.53464888502786)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 1208226, 1208227, 1208228]), 'TEST:', array([724938, 724939, 724940, ..., 966581, 966582, 966583]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 2.2184613860519105)\n",
      "('Mean Squared Error of XGBoost Kfold:', 640.8095154084018)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 25.314215678318018)\n",
      "('TRAIN:', array([     0,      1,      2, ..., 966581, 966582, 966583]), 'TEST:', array([ 966584,  966585,  966586, ..., 1208226, 1208227, 1208228]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 1.513140427088732)\n",
      "('Mean Squared Error of XGBoost Kfold:', 1156.608973764211)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 34.0089543174178)\n"
     ]
    }
   ],
   "source": [
    "rmse_list = []\n",
    "for train_index, test_index in kf.split(X,y):\n",
    "    print(\"TRAIN:\", train_index, \"TEST:\", test_index)\n",
    "    X_train, X_test = X[train_index], X[test_index]\n",
    "    y_train, y_test = y[train_index], y[test_index]\n",
    "    regressor = xgb.XGBRegressor(\n",
    "                n_estimators=100,\n",
    "                reg_lambda=1,\n",
    "                gamma=0,\n",
    "                max_depth=40\n",
    "                )\n",
    "    regressor.fit(X_train, y_train)\n",
    "    y_pred = regressor.predict(X_test)\n",
    "    rmse_list.append(np.sqrt(metrics.mean_squared_error(y_test, y_pred)))\n",
    "    print('Mean Absolute Error of XGBoost Kfold:', metrics.mean_absolute_error(y_test, y_pred))\n",
    "    print('Mean Squared Error of XGBoost Kfold:', metrics.mean_squared_error(y_test, y_pred))\n",
    "    print('Root Mean Squared Error of XGBoost Kfold:', np.sqrt(metrics.mean_squared_error(y_test, y_pred)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean RMSE is :', 31.821265124277488)\n"
     ]
    }
   ],
   "source": [
    "rmse_sum = 0\n",
    "for index in range(0,5):\n",
    "    rmse_sum = rmse_sum + rmse_list[index]\n",
    "mean_rmse = rmse_sum/5\n",
    "print(\"Mean RMSE is :\",mean_rmse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "importances = regressor.feature_importances_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f72569223d0>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "(pd.Series(importances, index=featureslist[0:11]).plot(kind='barh')) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature: 0, Score: 0.33485\n",
      "Feature: 1, Score: 0.07510\n",
      "Feature: 2, Score: 0.05852\n",
      "Feature: 3, Score: 0.02120\n",
      "Feature: 4, Score: 0.11124\n",
      "Feature: 5, Score: 0.08132\n",
      "Feature: 6, Score: 0.03654\n",
      "Feature: 7, Score: 0.13483\n",
      "Feature: 8, Score: 0.10347\n",
      "Feature: 9, Score: 0.02288\n",
      "Feature: 10, Score: 0.02004\n"
     ]
    }
   ],
   "source": [
    "for i,v in enumerate(importances):\n",
    "\tprint('Feature: %0d, Score: %.5f' % (i,v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.model_selection import StratifiedKFold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "skf = StratifiedKFold(n_splits=5)\n",
    "skf.get_n_splits(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('TRAIN:', array([  23768,   34914,   35126, ..., 2174191, 2174192, 2174193]), 'TEST:', array([      0,       1,       2, ..., 2159952, 2171509, 2173182]))\n",
      "('Mean Absolute Error:', 5.949280055687577)\n",
      "('Mean Squared Error:', 10379.061088653152)\n",
      "('Root Mean Squared Error:', 101.8776770870496)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 2174191, 2174192, 2174193]), 'TEST:', array([  23768,   34914,   35126, ..., 2129262, 2159922, 2159923]))\n",
      "('Mean Absolute Error:', 4.633791164619073)\n",
      "('Mean Squared Error:', 497.5076613690275)\n",
      "('Root Mean Squared Error:', 22.30487976585006)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 2174191, 2174192, 2174193]), 'TEST:', array([  92202,  136785,  137423, ..., 2129237, 2129241, 2159926]))\n",
      "('Mean Absolute Error:', 4.548931450654503)\n",
      "('Mean Squared Error:', 355.0415171536141)\n",
      "('Root Mean Squared Error:', 18.842545400067745)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 2174191, 2174192, 2174193]), 'TEST:', array([ 275195,  370536,  370708, ..., 2159929, 2159936, 2160004]))\n",
      "('Mean Absolute Error:', 4.556982226090707)\n",
      "('Mean Squared Error:', 280.0801557350681)\n",
      "('Root Mean Squared Error:', 16.735595469987558)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 2160004, 2171509, 2173182]), 'TEST:', array([ 616306,  819822,  821675, ..., 2174191, 2174192, 2174193]))\n",
      "('Mean Absolute Error:', 4.530887703035336)\n",
      "('Mean Squared Error:', 282.22241057946184)\n",
      "('Root Mean Squared Error:', 16.79947649718472)\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "rmse_list = []\n",
    "for train_index, test_index in skf.split(X,y):\n",
    "    print(\"TRAIN:\", train_index, \"TEST:\", test_index)\n",
    "    X_train, X_test = X[train_index], X[test_index]\n",
    "    y_train, y_test = y[train_index], y[test_index]\n",
    "    regressor = RandomForestRegressor(n_estimators=100, max_depth=3, random_state=0)\n",
    "    regressor.fit(X_train, y_train)\n",
    "    y_pred = regressor.predict(X_test)\n",
    "    rmse_list.append(np.sqrt(metrics.mean_squared_error(y_test, y_pred)))\n",
    "    print('Mean Absolute Error:', metrics.mean_absolute_error(y_test, y_pred))\n",
    "    print('Mean Squared Error:', metrics.mean_squared_error(y_test, y_pred))\n",
    "    print('Root Mean Squared Error:', np.sqrt(metrics.mean_squared_error(y_test, y_pred)))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[101.8776770870496,\n",
       " 22.30487976585006,\n",
       " 18.842545400067745,\n",
       " 16.735595469987558,\n",
       " 16.79947649718472]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rmse_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean RMSE is :', 35.312034844027934)\n"
     ]
    }
   ],
   "source": [
    "rmse_sum = 0\n",
    "for index in range(0,5):\n",
    "    rmse_sum = rmse_sum + rmse_list[index]\n",
    "mean_rmse = rmse_sum/5\n",
    "print(\"Mean RMSE is :\",mean_rmse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import xgboost as xgb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('TRAIN:', array([  23768,   34914,   35126, ..., 2174191, 2174192, 2174193]), 'TEST:', array([      0,       1,       2, ..., 2159952, 2171509, 2173182]))\n",
      "('Mean Absolute Error:', 4.14947807428083)\n",
      "('Mean Squared Error:', 8108.059212051534)\n",
      "('Root Mean Squared Error:', 90.0447622688379)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 2174191, 2174192, 2174193]), 'TEST:', array([  23768,   34914,   35126, ..., 2129262, 2159922, 2159923]))\n",
      "('Mean Absolute Error:', 2.8374867180176166)\n",
      "('Mean Squared Error:', 196.87616638989186)\n",
      "('Root Mean Squared Error:', 14.031256764448859)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 2174191, 2174192, 2174193]), 'TEST:', array([  92202,  136785,  137423, ..., 2129237, 2129241, 2159926]))\n",
      "('Mean Absolute Error:', 2.7777759943312947)\n",
      "('Mean Squared Error:', 152.18036605531404)\n",
      "('Root Mean Squared Error:', 12.336140646706086)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 2174191, 2174192, 2174193]), 'TEST:', array([ 275195,  370536,  370708, ..., 2159929, 2159936, 2160004]))\n",
      "('Mean Absolute Error:', 2.672835373122593)\n",
      "('Mean Squared Error:', 113.25099187874304)\n",
      "('Root Mean Squared Error:', 10.641944929322978)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 2160004, 2171509, 2173182]), 'TEST:', array([ 616306,  819822,  821675, ..., 2174191, 2174192, 2174193]))\n",
      "('Mean Absolute Error:', 2.695106220601736)\n",
      "('Mean Squared Error:', 158.2709398640983)\n",
      "('Root Mean Squared Error:', 12.580577882756351)\n"
     ]
    }
   ],
   "source": [
    "rmse_list = []\n",
    "for train_index, test_index in skf.split(X,y):\n",
    "    print(\"TRAIN:\", train_index, \"TEST:\", test_index)\n",
    "    X_train, X_test = X[train_index], X[test_index]\n",
    "    y_train, y_test = y[train_index], y[test_index]\n",
    "    regressor = xgb.XGBRegressor(\n",
    "                n_estimators=100,\n",
    "                reg_lambda=1,\n",
    "                gamma=0,\n",
    "                max_depth=3\n",
    "                )\n",
    "    regressor.fit(X_train, y_train)\n",
    "    y_pred = regressor.predict(X_test)\n",
    "    rmse_list.append(np.sqrt(metrics.mean_squared_error(y_test, y_pred)))\n",
    "    print('Mean Absolute Error:', metrics.mean_absolute_error(y_test, y_pred))\n",
    "    print('Mean Squared Error:', metrics.mean_squared_error(y_test, y_pred))\n",
    "    print('Root Mean Squared Error:', np.sqrt(metrics.mean_squared_error(y_test, y_pred)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean RMSE is :', 27.92693649841443)\n"
     ]
    }
   ],
   "source": [
    "rmse_sum = 0\n",
    "for index in range(0,5):\n",
    "    rmse_sum = rmse_sum + rmse_list[index]\n",
    "mean_rmse = rmse_sum/5\n",
    "print(\"Mean RMSE is :\",mean_rmse)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}