ModelPhilosophy.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=\"philosophymodel\", 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": [
    "philFOSID = spark.read.options(header = True, inferSchema = True,delimiter=',').csv(\"FOSDomains.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "philFOSID = philFOSID.filter(philFOSID[\"Domain\"]==\"Philosophy\").collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "315"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(philFOSID)"
   ]
  },
  {
   "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(philFOSID)\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",
      "| 19417346|Philosophy|\n",
      "|124952713|Philosophy|\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": [
       "2841454"
      ]
     },
     "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": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "(sample1,sample2) = papers_filtered1.randomSplit([0.4,0.5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1261814"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample1.count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import model_selection\n",
    "from sklearn.model_selection import KFold "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------+\n",
      "|EstimatedCount|\n",
      "+--------------+\n",
      "|             0|\n",
      "|             0|\n",
      "|             1|\n",
      "|             0|\n",
      "+--------------+\n",
      "only showing top 4 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "papers_filtered1.select([\"EstimatedCount\"]).show(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample1_pd = sample1.toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "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": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean Absolute Error of EstimatedCount:', 0.805097264731569)\n",
      "('Mean Squared Error of EstimatedCount:', 2160.428680455281)\n",
      "('Root Mean Squared of with EstimatedCount:', 46.48041179309066)\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": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample1_pd = sample1_pd.drop([\"PaperID\",\"EstimatedCount\"],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1261814, 12)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample1_pd.shape"
   ]
  },
  {
   "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": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import KFold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kf = KFold(n_splits=5)\n",
    "kf.get_n_splits(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean Absolute Error:', 1.1157685109312467)\n",
      "('Mean Squared Error:', 81.24233100182342)\n",
      "('Root Mean Squared Error:', 9.013452779142042)\n",
      "('Mean Absolute Error:', 0.4754281770540033)\n",
      "('Mean Squared Error:', 114.75601561433594)\n",
      "('Root Mean Squared Error:', 10.712423423966023)\n",
      "('Mean Absolute Error:', 1.1590772729761054)\n",
      "('Mean Squared Error:', 439.3135435748294)\n",
      "('Root Mean Squared Error:', 20.959807813403952)\n",
      "('Mean Absolute Error:', 0.8071434600916314)\n",
      "('Mean Squared Error:', 93.97226011787905)\n",
      "('Root Mean Squared Error:', 9.69392903408515)\n",
      "('Mean Absolute Error:', 0.6073511040906939)\n",
      "('Mean Squared Error:', 234.68087900290652)\n",
      "('Root Mean Squared Error:', 15.319297601486385)\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": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean RMSE is :', 13.13978213041671)\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 matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "featureslist=sample1_pd.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "importances = regressor.feature_importances_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fde11a9d490>"
      ]
     },
     "execution_count": 40,
     "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": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "import xgboost as xgb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kf = KFold(n_splits=5)\n",
    "kf.get_n_splits(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('TRAIN:', array([ 252363,  252364,  252365, ..., 1261811, 1261812, 1261813]), 'TEST:', array([     0,      1,      2, ..., 252360, 252361, 252362]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 1.1850737282986537)\n",
      "('Mean Squared Error of XGBoost Kfold:', 118.74620883900948)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 10.897073407067124)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 1261811, 1261812, 1261813]), 'TEST:', array([252363, 252364, 252365, ..., 504723, 504724, 504725]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 0.4970600931884348)\n",
      "('Mean Squared Error of XGBoost Kfold:', 135.79631937763054)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 11.653167782952005)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 1261811, 1261812, 1261813]), 'TEST:', array([504726, 504727, 504728, ..., 757086, 757087, 757088]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 1.2193320991410865)\n",
      "('Mean Squared Error of XGBoost Kfold:', 321.64896585068044)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 17.934574593524108)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 1261811, 1261812, 1261813]), 'TEST:', array([ 757089,  757090,  757091, ..., 1009449, 1009450, 1009451]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 0.8682189758512436)\n",
      "('Mean Squared Error of XGBoost Kfold:', 195.21543386554063)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 13.971951684197188)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 1009449, 1009450, 1009451]), 'TEST:', array([1009452, 1009453, 1009454, ..., 1261811, 1261812, 1261813]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 0.6524892543229086)\n",
      "('Mean Squared Error of XGBoost Kfold:', 314.06430753298145)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 17.721859595792463)\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": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean RMSE is :', 14.435725412706578)\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": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "importances = regressor.feature_importances_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fddf55a10d0>"
      ]
     },
     "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.39612\n",
      "Feature: 1, Score: 0.04709\n",
      "Feature: 2, Score: 0.08015\n",
      "Feature: 3, Score: 0.02336\n",
      "Feature: 4, Score: 0.12026\n",
      "Feature: 5, Score: 0.04519\n",
      "Feature: 6, Score: 0.03639\n",
      "Feature: 7, Score: 0.12555\n",
      "Feature: 8, Score: 0.09021\n",
      "Feature: 9, Score: 0.02433\n",
      "Feature: 10, Score: 0.01135\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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "drop_cols = [\"FOS_ID\",\"PaperID\",\"EstimatedCount\",\"Domain\",\"PaperYear\",\"Volume\",\"Issue\"]\n",
    "papers_filtered = papers_filtered.drop(*drop_cols)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "papers_filtered1 = papers_filtered.select([\"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": [
    "from sklearn import model_selection\n",
    "from sklearn.model_selection import KFold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(papers_filtered.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "papers_pd = papers_filtered1.toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = papers_pd.iloc[:, 0:11].values\n",
    "y = papers_pd.iloc[:, 11].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 1], dtype=int32)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[0:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "kfold = model_selection.KFold(n_splits=5, random_state=10)\n",
    "model = RandomForestRegressor(n_estimators= 1000,max_depth=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "results = model_selection.cross_val_score(model, X, y, cv=kfold,scoring=\"neg_mean_absolute_error\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Neg Mean Abosulte error: %.3f%% \" % (results.mean()))"
   ]
  }
 ],
 "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
}