ModelChemistry.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=\"chemmodel\", 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": [
    "chemFOSID = spark.read.options(header = True, inferSchema = True,delimiter=',').csv(\"FOSDomains.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "chemFOSID = chemFOSID.filter(chemFOSID[\"Domain\"]==\"Chemistry\").collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "136"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(chemFOSID)"
   ]
  },
  {
   "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(chemFOSID)\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",
      "|179104552|Chemistry|\n",
      "| 31903555|Chemistry|\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": [
       "6924804"
      ]
     },
     "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": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "(sample1,sample2) = papers_filtered1.randomSplit([0.12,0.5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1340431"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample1.count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import model_selection\n",
    "from sklearn.model_selection import KFold "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------+\n",
      "|EstimatedCount|\n",
      "+--------------+\n",
      "|             9|\n",
      "|             4|\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": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample1_pd = sample1.toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean Absolute Error of EstimatedCount:', 1.7563261368917908)\n",
      "('Mean Squared Error of EstimatedCount:', 381.435205542098)\n",
      "('Root Mean Squared of with EstimatedCount:', 19.53036624188338)\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": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample1_pd = sample1_pd.drop([\"PaperID\",\"EstimatedCount\"],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1340431, 12)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sample1_pd.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import KFold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kf = KFold(n_splits=5)\n",
    "kf.get_n_splits(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean Absolute Error:', 2.9850797234939583)\n",
      "('Mean Squared Error:', 131.52216620726102)\n",
      "('Root Mean Squared Error:', 11.468311393019507)\n",
      "('Mean Absolute Error:', 2.2603481970485966)\n",
      "('Mean Squared Error:', 139.15946385612176)\n",
      "('Root Mean Squared Error:', 11.796586957934984)\n",
      "('Mean Absolute Error:', 0.6592061730837382)\n",
      "('Mean Squared Error:', 7.384485854898274)\n",
      "('Root Mean Squared Error:', 2.7174410490198815)\n",
      "('Mean Absolute Error:', 2.794373448305072)\n",
      "('Mean Squared Error:', 296.072276901151)\n",
      "('Root Mean Squared Error:', 17.206750910649895)\n",
      "('Mean Absolute Error:', 2.9844503108915537)\n",
      "('Mean Squared Error:', 306.9375105996091)\n",
      "('Root Mean Squared Error:', 17.519632147953594)\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": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean RMSE is :', 12.141744491715572)\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": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "featureslist=sample1_pd.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "importances = regressor.feature_importances_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fbb4ecae790>"
      ]
     },
     "execution_count": 44,
     "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": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature: 0, Score: 0.57139\n",
      "Feature: 1, Score: 0.04555\n",
      "Feature: 2, Score: 0.27435\n",
      "Feature: 3, Score: 0.00430\n",
      "Feature: 4, Score: 0.00709\n",
      "Feature: 5, Score: 0.02184\n",
      "Feature: 6, Score: 0.00623\n",
      "Feature: 7, Score: 0.02286\n",
      "Feature: 8, Score: 0.01961\n",
      "Feature: 9, Score: 0.01369\n",
      "Feature: 10, Score: 0.01308\n"
     ]
    }
   ],
   "source": [
    "for i,v in enumerate(importances):\n",
    "\tprint('Feature: %0d, Score: %.5f' % (i,v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## XGBoost Regression model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "import xgboost as xgb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kf = KFold(n_splits=5)\n",
    "kf.get_n_splits(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('TRAIN:', array([ 268087,  268088,  268089, ..., 1340428, 1340429, 1340430]), 'TEST:', array([     0,      1,      2, ..., 268084, 268085, 268086]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 3.159447244634123)\n",
      "('Mean Squared Error of XGBoost Kfold:', 174.4968455266639)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 13.209725414506687)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 1340428, 1340429, 1340430]), 'TEST:', array([268087, 268088, 268089, ..., 536170, 536171, 536172]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 2.3620001926714567)\n",
      "('Mean Squared Error of XGBoost Kfold:', 142.5090994587869)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 11.937717514616724)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 1340428, 1340429, 1340430]), 'TEST:', array([536173, 536174, 536175, ..., 804256, 804257, 804258]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 0.6683669800412606)\n",
      "('Mean Squared Error of XGBoost Kfold:', 7.543893457724273)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 2.7466149088877154)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 1340428, 1340429, 1340430]), 'TEST:', array([ 804259,  804260,  804261, ..., 1072342, 1072343, 1072344]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 2.9171084028046175)\n",
      "('Mean Squared Error of XGBoost Kfold:', 313.61181121304327)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 17.70908837893818)\n",
      "('TRAIN:', array([      0,       1,       2, ..., 1072342, 1072343, 1072344]), 'TEST:', array([1072345, 1072346, 1072347, ..., 1340428, 1340429, 1340430]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 3.073380420272174)\n",
      "('Mean Squared Error of XGBoost Kfold:', 336.5723452069319)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 18.345908132521867)\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": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean RMSE is :', 12.789810869894234)\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": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "importances = regressor.feature_importances_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fbb319b9f10>"
      ]
     },
     "execution_count": 52,
     "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": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature: 0, Score: 0.34553\n",
      "Feature: 1, Score: 0.10115\n",
      "Feature: 2, Score: 0.06291\n",
      "Feature: 3, Score: 0.01278\n",
      "Feature: 4, Score: 0.03250\n",
      "Feature: 5, Score: 0.13407\n",
      "Feature: 6, Score: 0.00672\n",
      "Feature: 7, Score: 0.15082\n",
      "Feature: 8, Score: 0.11663\n",
      "Feature: 9, Score: 0.00858\n",
      "Feature: 10, Score: 0.02831\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": 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, 0], dtype=int32)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[0:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import median_absolute_error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "results = model_selection.cross_val_score(model, X, y, cv=kfold,scoring=\"neg_mean_absolute_error\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Neg Mean Abosulte error: -5.767% \n"
     ]
    }
   ],
   "source": [
    "print(\"Neg Mean Abosulte error: %.3f%% \" % (results.mean()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-5.03701221, -5.07693192, -5.07743707, -6.46592026, -7.1768768 ])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "results"
   ]
  },
  {
   "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
}