ModelGeography.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=\"geographymodel\", 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": [
    "geogFOSID = spark.read.options(header = True, inferSchema = True,delimiter=',').csv(\"FOSDomains.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "geogFOSID = geogFOSID.filter(geogFOSID[\"Domain\"]==\"Geography\").collect()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(geogFOSID)"
   ]
  },
  {
   "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(geogFOSID)\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",
      "| 26271046|Geography|\n",
      "|100970517|Geography|\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": [
       "856842"
      ]
     },
     "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 = papers_filtered1"
   ]
  },
  {
   "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": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------+\n",
      "|EstimatedCount|\n",
      "+--------------+\n",
      "|            25|\n",
      "|           144|\n",
      "|             8|\n",
      "|             3|\n",
      "+--------------+\n",
      "only showing top 4 rows\n",
      "\n"
     ]
    }
   ],
   "source": [
    "papers_filtered1.select([\"EstimatedCount\"]).show(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample1_pd = sample1.toPandas()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean Absolute Error of EstimatedCount:', 0.325608455234454)\n",
      "('Mean Squared Error of EstimatedCount:', 307.12154049404677)\n",
      "('Root Mean Squared of with EstimatedCount:', 17.52488346591916)\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": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample1_pd = sample1_pd.drop([\"PaperID\",\"EstimatedCount\"],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import KFold"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kf = KFold(n_splits=5)\n",
    "kf.get_n_splits(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestRegressor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean Absolute Error:', 0.9768786033692295)\n",
      "('Mean Squared Error:', 135.68020839976586)\n",
      "('Root Mean Squared Error:', 11.648184768442071)\n",
      "('Mean Absolute Error:', 0.20501445991016562)\n",
      "('Mean Squared Error:', 4.184603419726685)\n",
      "('Root Mean Squared Error:', 2.045630323329874)\n",
      "('Mean Absolute Error:', 0.21809275639944187)\n",
      "('Mean Squared Error:', 12.204195099556275)\n",
      "('Root Mean Squared Error:', 3.4934503144536455)\n",
      "('Mean Absolute Error:', 0.24092691823092482)\n",
      "('Mean Squared Error:', 30.442495273801406)\n",
      "('Root Mean Squared Error:', 5.517471819031014)\n",
      "('Mean Absolute Error:', 0.35577488072240104)\n",
      "('Mean Squared Error:', 17.477181071054282)\n",
      "('Root Mean Squared Error:', 4.180571859333874)\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": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean RMSE is :', 5.377061816918096)\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": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "featureslist=sample1_pd.columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "importances = regressor.feature_importances_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fea0966a390>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdoAAAD8CAYAAADQZmUwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzt3XucVXW9//HXW7yANyxFAzXHC8oRFJSB1NS85bHjPS1vp0JL9BwvZQcvmb+yLO8ej6alWIkVlpfUUDumKSh5w0EuA4gXQDtZIlqiCKIOn98f67tjsZ2ZvWeYNXsG3s/HYz9Y+7u+67s+a4N+5vtda/ZHEYGZmZkVY41aB2BmZrYqc6I1MzMrkBOtmZlZgZxozczMCuREa2ZmViAnWjMzswI50ZqZmRXIidbMzKxATrRmZmYFWrPWAVjtbbLJJlFXV1frMMzMupXJkye/ERF9KvVzojXq6upoaGiodRhmZt2KpFeq6eelYzMzswI50ZqZmRXIidbMzKxATrRG46sLqTvv/lqHYWa2SnKiNTMzK9BqmWglNUmaKmmGpDskrVvw+UZIWpDOOVvSWVUcs46kP6ZjjpG0lqRLJb0o6VlJT0r6XIUxjpC0Y8ddiZmZtdVqmWiBJRExJCIGAe8DpxZ1IkmlX6G6LSKGAJ8Gvi1pywqH7gKQ4rwNuAjoCwyKiF2BI4ANKoxxBOBEa2ZWQ6tros2bCGwHIOkeSZMlzZQ0stRB0iJJV6f2hyX1Se3bSnogHTNR0oDUPkbSDZKeBi7Pnywi3gReIkuaSOoj6beSnkmvT0vaFPgVMCzNaAcCJwNnRMTSNM78iLg9F98PJU2T9JSkzSTtARwGXJHG2LbID9HMzJq3WifaNNv8HNCYmk6KiKFAPXCmpI1T+3pAQ0QMBB4FvpvaR5Mlv6HAKODHueG3APaIiG+WnfOTQE9gemq6Brg6IoYBRwE/jYjXga8BE9MsuAfw54h4u4VLWQ94KiIGA48BJ0fEE8A44Ow0K55TFsdISQ2SGpoWL6zi0zIzs/ZYXb8ZqpekqWl7IvCztH2mpCPT9pZAf+BNYBlwW2r/FXCXpPWBPYA7JJXGXSd3jjsioin3/hhJewMDgNMj4r3UfgCwY26MDdPYbfE+cF/angx8ttIBETGa7AcF1unbP9p4PjMzq9LqmmiXpJniP0nahyzp7R4RiyVNIJt5NifIVgPeKh8n592y97dFxOmS6oEHJY2LiNfSOLvlEm8pnvzbl4BPStqwhVntBxFRSpZNrL5/r2ZmXc5qvXRcpjfwj5RkBwC75fatARydto8H/pQS3jxJXwBQZnClk0REA/BL4Oup6UHgjNJ+SR9J3BGxmGzWfY2ktVO/PqVzt+IdKj8wZWZmBXKiXe4BYE1JzwGXAk/l9r0LDJc0A9gP+H5qPwH4qqRpwEzg8CrPdRlwoqQNgDOBeknTJc2i5SegLwAWALNSHPcBLd2zLfkNcLakKX4YysysNrR8xdFaImlRRLT1vmm3UV9fH67eY2bWNpImR0R9pX6e0ZqZmRXIibYKq/Js1szMiuVEa2ZmViAnWjMzswI50ZqZmRXIidbMzKxATrRmZmYFcqI1MzMrkBOtmZlZgfzl88a0dxbzifFTW9z/2r4t1U0wM7NKPKM1MzMrUJdJtJJGSFogaWp6/SK1S9IFkl6U9IKk8ZIG5o47SVJj+lL+GZIOz+0bJWl2Gu8ZSV9O7T+VtGPaPr/K+M4ve//ESlzrWpIuTdf0rKQnJX2uveO1cI46Scd35JhmZtZ2XW3p+LaIOL2s7TSyAuuDUwm7A4FxKdluAnwb2DUiFqaC6X0AJJ1KVgB9eES8LWlD4EiAiPhabvzzgYuriG2FfhGxR7uuMHMR0BcYFBFLJW0GfGYlxmtOHVlJv1s7eFwzM2uDijPaNDOaLWlMmlGOlXSApMfTjGx4ej2ZyrE9IWmHdOxZkn6etndKM8512xjjucDpqSYrEfEg8ARZibpNyWquLkr7FkXEvHTc+cB/lAqlR8TbEXFLimWCpHpJlwK90ox3bNp3j6TJkmZKGpnamuu3KP0pSVeka2uUdExq3yed5870+Y1NfdcFTgbOiIilKbb5EXF7Ou64NM4MSZfl/h4W5baPljQmbY+RdG363OdKKtXNvRTYK8V8Vhs/czMz6yDVLh1vB1wFDEiv44E9gVFkCW02sFdE7AJ8h+Uzv2uA7SQdCdwMnFJKmC04Jrd0fGKaha4XEXPL+jUAA4FpwHyyAuw3SzoUIB23QTPHrSAizgOWRMSQiDghNZ8UEUOBeuBMSRu30K/k88AQYDBwAHCFpL5p3y7AN4AdgW2AT6fP8s+lHwDyJPUjq1W7XxpzmKQjWruGpC/Z38chZAkW4DxgYor56mbONVJSg6SGZQvfquIUZmbWHtUuHc+LiEYASTOBhyMiJDWSLVH2Bm6R1B8IYC2AiFgmaQQwHbgxIh6vcJ4Vlo5TwmxRRDRJOggYBuwPXC1pKPDfVV5Xc85MPxgAbAn0B95spf+ewK8jogmYL+nRFM/bwKSI+Eu6lqlkn9X0VsYaBkyIiAXpmLHA3sA9FWK+JyKWkRWF36xCXwAiYjQwGmCtHXZ0UWIzs4JUO6Ndmttelnu/jCxZXwSMj4hBwKFAz1z//mRLu/3aGlya9b0raZuyXUOBmalPRMSkiLgEOBY4Kh23qJnjWiVpH7JZ6e4RMRiYUnYtbZX/3JrIPquXgE9W+iGiGflkWB5T/jxq47hmZlagjnrquDfwatoeUWqU1Bu4lmxWtnHu/mFbXAFcK6lXGvMAslnkrZL6Sdo113cI8EravgS4vpTQJK1feuq4zAeS1spdxz/SQ1cDgN1a6Jc3kWzJu4ekPulaJ7V0MWnp/GfANZLWTrH1kfSFdNxnJG0iqQdwHPBoOnS+pH+RtAbpoa4K3gE2qKKfmZkVqKMS7eXAJZKmsOJy9NXA9RHxAvBV4FJJm7Zx7B8BzwCNkp4H/h9weEQsIVuivjI9bDQVOAb4ejruJ8B44BlJM8gS4rJmxh8NTE/LtA8Aa0p6juxe51Mt9Mu7m2w5eBrwCHBORLxW4ZouABaQLfXOAO4D3o6Iv5HdWx2fxpscEb9Lx5yX+j0B/K3C+KSYmiRN88NQZma1owjfnlvd1dfXR0NDQ63DMDPrViRNjoj6Sv26zBdWmJmZrYo6/QsrJJ3I8uXdkscj4rTOjsXMzKxonZ5oI+Jmst+pNTMzW+V56djMzKxATrRmZmYFcqI1MzMrkBOtmZlZgZxozczMCuREa2ZmVqCuVvjdauCddxp5+JFtV2jbf785NYrGzGzV4hmtmZlZgTo80Uo6TNJ57TiuTtKSXOH3qbnqNkdImi7pOUmN+WLoknaT9HTq/5ykC3P7PpeKm8+SNEXSVan91FIlH0kjUsH1SvGt0E/STyXt2NbrzB3/ZUkz0vVMkTSqvWO1co7zO3pMMzNrmw5fOo6IccC4dh4+JyKG5BskDQauBD4bEfMkbQ08JGluREwHbgG+GBHTUmm5HdJxg4DrgIMjYnbaNzLFeEPuFCOAGcBfK8S2Qr+I+Fo7rxFJnwO+ARwYEX+VtA7QXAm/lXU+cHEB45qZWZXaNKNNs87ZksZIekHSWEkHSHpc0ouShqeZ33Wp/xhJ10p6QtLcdtajHQVcHBHzANKflwBnp/2bksrGRURTRMxK7ecAP4yI2bl9P0lxXShpVIqnHhibZsS9JH1H0jNptjlameb6TZBUn8Y7Ls1MZ0i6LPd5LZL0w1Sq7ilJm6Vd3wJGRUQpaS+NiJvSMUNS3+mS7pb0sdSeP98mkl5O2yMk3SXpgfR3cHlqvxToleItL+1nZmadpD1Lx9sBVwED0ut4skLso8hmUOX6pv2HkNV4bc22uWXj61PbQGByWb+G1A5ZzdvnU1I6RVLP1D6omeNWEBF3prFOiIghqcbtdRExLCIGAb2AQ1roB0BaTr4M2I+s8Pyw3NL2esBTETEYeAw4uYrYfgGcGxE7A43Ad1u7hmQIWS3enciK0G8ZEecBS1K8J5QfIGlkWlZveOut5sr0mplZR2hPop0XEY0RsQyYCTwcWVHbRqCumf73RMSyNNPcrJn9eXNSYhhSbTWfiPg+2WzzQbKk/0C1F9KCfdM930ay5DmwQv9hwISIWBARHwJjgb3TvvfJirVDlljrWhtIUm9go4h4NDXdkhurNQ9HxMKIeA+YBWxV6YCIGB0R9RFRv9FGfibOzKwo7fk/7NLc9rLc+2U0f88331/tON8sYGhZ21CyJA9ARMxJy8L7A4MlbZz2lx/XqjQb/jFwdETsBNwE9Gz9qFZ9kH4IAWhi+efT5tiAD1n+91UeU/4zzp/HzMxqrDtMZa4EviWpDrL7xGRL1KUniA+WVErg/ckSzVvAFcD5krZP/daQdGoz478DbJC2SwnsDUnrA0e30C9vEvCZdN+0B3Ac8Ggz/fIuAa6Q9IkU29qSvhYRC4F/SNor9ftSbqyXWZ6cq73X/YGktarsa2ZmBejyM5+ImCrpXODelDQ+AM6JiKmpy5eAqyUtJpv1nRARTcB0Sd8Afi1pXSBYvoybNwa4QdISYHeyWewM4DXgmVb6leL7m7JfZxpPNmO/PyJ+V+Gafp8ejPpj+iEhgJ+n3V9J51kXmAucmNqvBG6XNBK4v7Xxc0aTfQ7PNnef1szMiqflK5u2uqqvr4+GhoZah2Fm1q1ImhwR9ZX6dYelYzMzs26r05eOJe0E/LKseWlEfKqzYzEzMytapyfaiGgk+71PMzOzVZ6Xjs3MzArkRGtmZlYgJ1ozM7MCOdGamZkVyInWzMysQE60ZmZmBeryX8FoxfvrX//KhRdeWHX/tvQ1M1vdeUZrZmZWoJolWkmHpS/jb+txdZKW5ArET5W0dtp3hKTpkp6T1JgrwI6k3VKd2alp/4WpfYSkBal9lqSTWzh1h5G0lqRLJb0o6VlJT0r6XAefo07S8R05ppmZtV3Nlo4jYhwwrp2Hz4mIFb5dStJgsgo3n42IeZK2Bh6SNDcippMVUf9iRExL5ex2yB1+W0ScLmlTYKakcRExv52xtSqd+yKgLzAoIpamSj6f6eBT1QHHA7d28LhmZtYGhcxo02xqtqQxkl6QNFbSAZIeT7O44WkmeV3qP0bStZKekDRXUrX1VvNGARdHxDyA9OclwNlp/6bA39K+poiYVT5ARLwOzAG2SjE+KWlKimuHFOsISb+TNCFdy3dz1/3vkial2fGNKakiaZGkqyRNAz4NnAycERFL03nnR8Ttqe9xaTY+Q9JlubEX5baPljSmwmd3KbBXiuWsdnyeZmbWAYpcOt6OrDj7gPQ6HtiTLCGe30z/vmn/IWRJojXb5paNr09tA4HJZf0aUjvA1cDzku6WdIqknmV9kbQNsA3wEjAb2CsidgG+A1yc6zocOArYGfiCpHpJ/wIcA3w6zbabgFIN2PWApyNiMFlR+j9HxNvNnL8fcBmwH9n3QQ/LL3+3ornP7jxgYkQMiYirmznXSEkNkhoWL15cxSnMzKw9ilw6npcKCCBpJvBwRISkRrJlzXL3RMQyYFZaSm3NR5aOK4mI70saCxxIlvSPA/ZJu4+RtCewFDglIv4uaUvgFkn9yQqzr5Ub7qGIeDNd211kSe5DYCjwTFbLnV7A66l/E/DbKsIcBkyIiAVp7LHA3sA9FY5ry2cHQESMJisMT79+/VyU2MysIEUm2qW57WW598taOG++v9pxvllkiW5arm0oMLP0JiLmAD+RdBOwQNLGaddtEXF62XgXAeMj4khJdcCE3L7yxBQp5lsi4lvNxPZeRDSl7ZeAT0rasLlZbSvy5yyfja/sZ2dmZgVZlX6950rgWykpkv48n2z5GkkHK001gf5ks8y3WhmvN/Bq2h5Rtu+zkj4uqRdwBPA48DBwdHqgirR/q/JBI2Ix8DPgmtzT0n0kfQGYBHxG0ibp/u5xwKPp0PmS/kXSGsCRFT8NeAfYoIp+ZmZWoFXmCysiYqqkc4F7Ja0FfACcExFTU5cvAVdLWky2zHtCRDQtz70fcTnZ0vEFwP1l+yaRLQVvAfwqIhoAUt8HUzL8ADgNeKWZsS8AfkC21Pse8C7wnYj4m7JfeRpPNjO9PyJ+l445D7gPWEB273n9Ch/JdKApPYA1prn7tCX9+vXzl1CYmRVEEb491xaSRgD1zSw1d1v19fXR0NBQ6zDMzLoVSZMjor5Sv1Vp6djMzKzL6bJLx5J2An5Z1rw0Ij5Vi3hKImIMMKaWMZiZWffRZRNt+tWgNv0Kj5mZWVfjpWMzM7MCOdGamZkVyInWzMysQE60ZmZmBXKiNTMzK1CXferYOs/7ry7iL+dNbLXPFpfu1UnRmJmtWjyjNTMzK5ATrZmZWYG6XaKVNELSglzh91+kdkm6QNKLkl6QNF7SwNxxJ0lqlDRd0gxJh6f2MZLmpbGelbR7J1zDJyT9RtIcSZMl/V7S9h18jn0k7dGRY5qZWdt113u0zdWPPQ3YAxgcEYslHQiMS8l2E+DbwK4RsVDS+kCf3LFnR8Sd6ZgbgZ2LCFrSmmTl+e4mq117bGofDGwGvNCBp9sHWAQ80YFjmplZG3XYjFZSnaTZaYb4gqSxkg6Q9HiaZQ5PryclTZH0hKQd0rFnSfp52t4pzTjXbWMI5wKnp3qvRMSDZEnmBGBTsvqsi9K+RRExr5kxHgO2S3GcLOkZSdMk/bYUT7q+GyQ1pOs8JLX3kHRFOma6pFNS+z6SJkoaR1acfl/gg4i4oXTSiJgWERPTrPyKdP2Nko7JjXFf7rO+LlURQtLLkr6XZuONkgakWrynAmelmfpHnmSSNDJdQ8PfF7dWltfMzFZGRy8db0dWaH1Aeh0P7AmMIivCPhvYKyJ2Ab4DXJyOuwbYTtKRwM3AKaWE2YJjckvHJ0raEFgvIuaW9WsABgLTgPnAPEk3Szq0hXEPBRrT9l0RMSwiBgPPAV/N9asDhgMHAzdI6pn2L4yIYcAw4GRJW6f+uwJfj4jtgUHA5BbO/3my73ceDBwAXCGpbyufQ8kbEbEr8BNgVES8DNwAXB0RQyLiI48UR8ToiKiPiPqPr7tRFacwM7P26Oil43mpGACSZgIPR0RIaiRLTr3Jiqn3BwJYCyAilqUZ2nTgxoh4vMJ5Vlg6Tom2RanA+0FkCXB/sgLwQyPiwtTlilS0fQHLE+ogST8ANiIrsv6H3JC3R8Qy4EVJc8l+qDgQ2FnS0alPb6A/8D4wqYUZdLk9gV9HRBMwX9KjKea3Kxx3V/pzMlmyNjOzLqKjZ7RLc9vLcu+XkSX1i4DxETGIbPbYM9e/P9nSbr+2njQi3gbelbRN2a6hwMzUJyJiUkRcAhwLHJXrd3aa+X02ImaktjFkS9E7Ad8rizXKQwAEnJHGGRIRW6fla4B3c31nprja4kNW/LvqWba/9Dk30X3vu5uZrZI6+6nj3sCraXtEqVFSb+BaYG9g49yssC2uAK6V1CuNeQDZDPFWSf0k7ZrrOwR4pcJ4GwB/k7QW2X3evC9IWkPStsA2wPNkM97/SP2RtL2k9ZoZ9xFgHUkjSw2Sdk73USeSLYv3kNSH7POYlGLdUdI6kjYim5VX8k66BjMzq6HOnv1cTrZ0fAFwf679auD6iHhB0leB8ZIei4jX2zD2j4CPAY2SmoDXgMMjYomkTYErJfUD3iNbIj61wnj/D3g69X2aFZPWn8kS4IbAqRHxnqSfki2PPytJ6bgjygdNS+lHAv8j6dwUz8vAN4A/AbuT3VMO4JyIeA1A0u3ADGAeMKWKz+Ne4E5lv8Z0RnP3aUvW3nx9f/OTmVlBFFG+CmqtkTQGuC8i7qx1LB2lvr4+Ghoaah2GmVm3ImlyRNRX6tftvrDCzMysO+myD85IOhH4elnz4xFxWi3iKYmIEbU8v5mZdS9dNtFGxM1kv1NrZmbWbXnp2MzMrEBOtGZmZgVyojUzMyuQE62ZmVmBnGjNzMwK1GWfOrbOM3/uS1x1zCEfaf+v2+5rpreZmbWFZ7RmZmYFcqJtB0kjJC3I1cT9RWqXpAtSofsXJI2XNDB33EmpOPv0VNz98NQ+RtK8NNY0SdUUDWgttutW/irNzKwjeOm4/VaoiZucBuwBDI6IxZIOBMalZLsJ8G1g14hYKGl9oE/u2LMj4k5J+wKjycoGmplZN7dKzWgl1UmanWaIL0gaK+kASY+nWebw9HpS0hRJT0jaIR17lqSfp+2d0oxz3TaGcC5ZDdvFAKke7RNkZfY2JStdtyjtW9RCMfgngc1z1/QdSc+keEanykBImiDpMkmT0rV+pPyOpIPTtW7SxuswM7MOskol2mQ74CpgQHodT1aXdhRwPjAb2CsidgG+A1ycjrsG2C6VsLsZOKWUMFtwTG7p+ERJGwLrRcTcsn4NwECy0nfzgXmSbpZ0aAvjHgTck3t/XUQMi4hBQC8g/9TSmhExnKzE3nfzg6TrOA/4t4h4o/wkkkZKapDU8O7S91u5TDMzWxmr4tLxvIhoBJA0E3g41YBtJKsX25usJm5/spqvawFExDJJI4DpwI0R8XiF86ywdJwSbYsioknSQcAwssLtV0saGhEXpi5XSLoY2IKsJm3JvpLOAdYFPg7MJKs1C3BX+nNyuraS/YB64MCIeLuFeEaTLVGz5cc3cq1EM7OCrIoz2qW57WW598vIfrC4CBifZoiHAj1z/fuTLe32a+tJU0J7V9I2ZbuGkiVHIjMpIi4BjgWOyvU7OyK2J1t+Li1h9wR+DBwdETsBN5XFW7q2Jlb8oWkOWaH67dt6HWZm1rFWxURbSW/g1bQ9otQoqTdwLbA3sLGko9sx9hXAtZJ6pTEPIFu2vlVSP0m75voOAV5pZozrgDUk/SvLk+ob6eGpamN6hSyJ/yL/1LOZmXW+VXHpuJLLyZaOLwDuz7VfDVwfES9I+iowXtJjEfF6G8b+EfAxoFFSE/AacHhELJG0KXClpH7Ae8AC4NTyAdIy9w+AcyJif0k3ATPSWM9UG0hEzJZ0AnCHpEMjYk4brsPMzDqIInx7bnVXX18fDQ0NtQ7DzKxbkTQ5Iuor9Vsdl47NzMw6zeq4dFw1SScCXy9rfjwiTqtFPGZm1v040bYiIm4m+51aMzOzdvHSsZmZWYGcaM3MzArkRGtmZlYgJ1ozM7MCOdGamZkVyInWzMysQP71HuP1V97h+lMfafNxp92wXwHRmJmtWjyjNTMzK9BqnWglHSbpvHYcVydpSa7w+1RJa6d9R0iaLuk5SY2Sjsgdt5ukp1P/5yRdmNpHSFqQ2mdLOmslrqlO0oz2Hm9mZh1rtV46johxwLh2Hj4nIobkGyQNBq4EPhsR8yRtDTwkaW5ETAduAb4YEdMk9QB2yB1+W0ScLmlj4HlJd0bE/7UzNjMz6yJW2RltmtnNljRG0guSxko6QNLjkl6UNDzNJK9L/cdIulbSE5LmtrMe7Sjg4oiYB5D+vAQ4O+3fFPhb2tcUEbPKB4iIN4GXgL4prkPTLHiKpD9K2iy1Xyjp55ImpHjPbOYz2CYdN6wd12JmZh1glU20yXbAVcCA9DqerBD7KOD8Zvr3TfsPAS6tMPa2uWXj61PbQGByWb+G1A5ZzdvnJd0t6RRJPcv6IumTZAXfp6emPwG7RcQuwG+Ac3LdBwD/CgwHvitprdw4OwC/BUZExEfq2EoaKalBUsOi996qcKlmZtZeq/rS8byIaASQNBN4OBVWbwTqmul/T0QsA2aVZo6t+MjScSUR8X1JY4EDyZL+ccA+afcxkvYmS56nR8R7qX0L4DZJfYG1gXm5Ie+PiKXAUkmvA6WY+wC/Az7f3Kw5xTIaGA3wyT47uCixmVlBVvUZ7dLc9rLc+2U0/0NGvr/acb5ZwNCytqHAzNKbiJgTET8B9gcGp3uykN2j3RnYA7hU0idS+4+A6yJiJ+AUstluc/E2sfyaFgJ/Jpudm5lZDa3qibazXQl8S1IdZPeJyZaor0rvD5ZUSuD9yZLjCuu2EdEA/JLldXB7A6+m7a9UGcf7wJHAlyUd3/bLMDOzjrKqLx13qoiYKulc4N50v/QD4JyImJq6fAm4WtJi4EPghIhoWp57/+ky4FlJFwMXAndI+gfwCLB1lbG8K+kQsqeeF6UnrM3MrJMpwrfnVnf19fXR0NBQ6zDMzLoVSZMjor5SPy8dm5mZFchLx62QtBPZ/dK8pRHxqVrEY2Zm3Y8TbSvSrwa16Vd4zMzM8rx0bGZmViAnWjMzswI50ZqZmRXIidbMzKxATrRmZmYFcqI1MzMrkBOt8d6MmZU7mZlZuzjRriRJiyrsf1nSJp0VTzPnbzU+MzMrlhNtNyHJXy5iZtYNOdF2EEl9JT0maaqkGZL2aqbPN9O+GZK+kdrqJM3I9Rkl6cK0PUHS/0hqAL4uaYykayU9IWmupKNTv/UlPSzpWUmNkg7vnKs2M7NKPEvqOMcDf4iIH0rqAayb3ylpKHAi8CmyovJPS3oU+EeFcdcuVYeQNAboS1bQfQAwDrgTeA84MiLeTsvUT0kaFy7NZGZWc060HecZ4OepDu09uRq0JXsCd0fEuwCS7gL2IkuWrbmt7P09EbEMmCVps9Qm4GJJewPLgM2BzYDXWhpU0khgJEDfNf3PwMysKF467iAR8RiwN/AqMEbSl6s89ENW/HvoWbb/3bL3S3PbpYrxJwB9gKERMQSY38w45fGOjoj6iKj/eA8nWjOzojjRdhBJWwHzI+Im4KfArmVdJgJHSFpX0nrAkaltPrCppI0lrQMc0o7T9wZej4gPJO0LbNXuCzEzsw7lqUzH2Qc4W9IHwCKgNKNdk6yG7bPpHuuk1P7TiJgCIOn7qf1VYHY7zj0WuFdSI9DQzjHMzKwA8vMyxZHUB5gaEZvXOpbWDOrZK2a8t6TWYZiZdSuSJpceVm2Nl44LIukwsqXhb9U6lkp6DhpY6xDMzFZZXjouSESMo/ITxWZmtorzjNbMzKxATrRmZmYFcqI1MzMrkBOtmZlZgZxozczMCuREa2ZmViAnWjMzswL592iNmW/OZKdbdqp1GAY0fqWx1iGYWQfzjNbMzKxATrRtIKlJ0lRJMyTdIWndykd1yHnvkfRUZ5zLzMw6lhORl+ymAAAL70lEQVRt2yyJiCERMQh4Hzi1qBNJWjP9uREwFOgtaZuizmdmZsVwom2/icB28M8Z52RJMyWNLHWQtEjS1an94VTNB0nbSnogHTNR0oDUPkbSDZKeBi5Pw3weuBf4DXBsbuxtJT0lqVHSDyQtyu07W9IzkqZL+l7RH4SZmbXMibYd0mzzc0DpyZWTImIoUA+cKWnj1L4e0BARA4FHge+m9tHAGemYUcCPc8NvAewREd9M748Dfp1ex+X6XQNcExE7AX/JxXYg0B8YDgwBhkrau5lrGCmpQVJD0ztN7fkYzMysCn7quG16SZqaticCP0vbZ0o6Mm1vSZbo3gSWAbel9l8Bd0laH9gDuENSadx1cue4IyKaACRtlsb6U0SEpA8kDYqIGcDuwBHpmFuBK9P2gek1Jb1fP43xWP5CImI0WcKn19a9XJTYzKwgTrRtsyQihuQbJO0DHADsHhGLJU0AerZwfJCtIrxVPk7Ou7ntLwIfA+alpLwh2az2263EKOCSiLix9UsxM7PO4KXjldcb+EdKsgOA3XL71gCOTtvHk81M3yZLnF8AUGZwC2MfBxwUEXURUUf2UFTpPu1TwFFp+9jcMX8ATkozZyRtLmnTlbpCMzNrNyfalfcAsKak54BLyRJgybvAcEkzgP2A76f2E4CvSpoGzAQOLx9UUh2wVX68iJgHLJT0KeAbwDclTSd7KGth6vMg2VLyk5IagTuBDTrqYs3MrG0U4dtzRZG0KCLWL2jsdcmWskPSscBxEfGRhF2N+vr6aGho6NgAzcxWcZImR0R9pX6+R9t9DQWuU3bz9i3gpBrHY2ZmzXCiLVBRs9k09kSgpXu7ZmbWRfgerZmZWYGcaM3MzArkRGtmZlYgJ1ozM7MCOdGamZkVyInWzMysQE60ZmZmBfLv0Rr8dQpc2Puj7Rcu7PxYzMxWMd1mRiupSdJUSTMk3StpoyqOOVPSc5LGdkaM1ZL0CUm/kTQnFX//vaTtO/gc+0jaoyPHNDOztus2iZZUoi4iBgF/B06r4pj/BD4bESdUc4JU0L1Q6SsT7wYmRMS2qfj7t4DNOvhU+5DVvTUzsxrqTok270lg89IbSWdLekbSdEnfS203ANsA/yvpLEnrSfq5pEmSpkg6PPUbIWmcpEeAh1sZry7Njm+SNFPSg5J6pX3bSfqjpGmSnpW0bUvjAPsCH0TEDaX4I2JaRExMJfOuSLP2RknHpHH2kXRf7nqvkzQibb8s6XvpvI2SBqTKP6cCZ6VVgL06/G/AzMyq0u3u0UrqAewP/Cy9PxDoDwwnK3o+TtLeEXGqpIOAfSPiDUkXA49ExElp2XmSpD+mYXcFdo6Iv7c0HvDn1H5cRJws6XayerC/AsYCl0bE3ZJ6Amu0Ms4gYHILl/d5YAjZdxhvAjwj6bEqPpY3ImJXSf8JjIqIr6UfNBZFxJVVHG9mZgXpTom2l6SpZDPZ54CHUvuB6TUlvV+fLMGVJ6gDgcMkjUrvewKfTNsPRcTfK4z3Z2BeRExN7ZOBOkkbAJtHxN0AEfEe/PMHgObGac2ewK8jogmYL+lRYBjwdoXj7srF9PkKfUnxjQRGAnyyt6o5xMzM2qE7JdolETEk1WH9A9k92mvJZouXRMSNFY4XcFREPL9CY1ZE/d2yfh8ZLy3HLs01NQG9KpyvuXH2B46uEGu5D1lxmb9n2f5SXE1U+XcaEaOB0QD1/Xq4KLGZWUG63T3aiFgMnAn8V3p46Q/ASZLWB5C0uaRNmzn0D8AZ6WEkJO3SwimqHa8UzzvAXyQdkfqvk/thoLlxHgHWSTNK0r6d033UicAxknpI6gPsDUwCXgF2TGNvRLZ0Xsk7wAZV9DMzswJ1u0QLEBFTgOlk90sfBG4FnpTUCNxJ8wnmImAtYLqkmel9c2NXO17el4AzJU0HngA+0dI4ERHAkcAB6dd7ZgKXAK+RPY08HZhGlpDPiYjXIuL/gNuBGenPKVR2L3CkH4YyM6stZf/ft9VZfb8e0TCymRr1/sIKM7MWSZocEfWV+nWne7RWlH67wIUNtY7CzGyV1C2Xjs3MzLoLJ1ozM7MCOdGamZkVyInWzMysQE60ZmZmBXKiNTMzK5ATrZmZWYGcaM3MzArkRGtmZlYgfzOU0fjqQurOu7/WYZiZdaqXLz24U87jGW0XIakpFQCYIeneVKWnvWNNkFTx+zfNzKx4TrRdx5KIGBIRg4C/k9XbNTOzbs6Jtmt6EtgcQNL6kh6W9KykRkmHp/Y6Sc9JuknSTEkPSlqhEL2kNSSNkfSDGlyDmZnhRNvlSOpBVth9XGp6DzgyInYF9gWuKhWvB/oD10fEQOAt4KjcUGsCY4EXI+KCTgnezMw+wom26+glaSpZAfjNgIdSu4CLU1H5P5LNdDdL++ZFxNS0PRmoy413IzAjIn7Y3MkkjZTUIKmhabHrzpqZFcWJtutYEhFDgK3IkmvpHu0JQB9gaNo/H+iZ9i3NHd/Eik+RPwHsK6knzYiI0RFRHxH1Pdbt3YGXYWZmeU60XUxELAbOBP5L0ppAb+D1iPhA0r5kibgaPwN+D9yexjEzsxpwou2CImIKMB04juw+a72kRuDLwOw2jPPfwBTgl5L8d21mVgOe6XQREbF+2ftDc293b+GwQbn+V+a298ltf7eDQjQzs3ZwojV22rw3DZ30DSlmZqsbLyeamZkVyInWzMysQE60ZmZmBXKiNTMzK5AiotYxWI1Jegd4vtZxrIRNgDdqHcRKcPy11d3jh+5/Dd01/q0iok+lTn7q2ACej4huW1ZPUoPjrx3HX3vd/Rq6e/yVeOnYzMysQE60ZmZmBXKiNYDRtQ5gJTn+2nL8tdfdr6G7x98qPwxlZmZWIM9ozczMCuREuxqRdJCk5yW9JOm8ZvavI+m2tP9pSXWdH2XLqoh/b0nPSvpQ0tG1iLE1VcT/TUmzJE2X9LCkaksidooq4j9VUqOkqZL+JGnHWsTZkkrx5/odJSkkdamnYKv4/EdIWpA+/6mSvlaLOFtSzecv6Yvpv4GZkm7t7BgLExF+rQYvoAcwB9gGWBuYBuxY1uc/gRvS9rHAbbWOu43x1wE7A78Ajq51zO2If19g3bT9H93w898wt30Y8ECt425L/KnfBsBjwFNAfa3jbuPnPwK4rtaxrkT8/cnKen4svd+01nF31Msz2tXHcOCliJgbEe8DvwEOL+tzOHBL2r4T2F+SOjHG1lSMPyJejojpwLJaBFhBNfGPj4jF6e1TwBadHGNrqon/7dzb9YCu9ABINf/+AS4CLgPe68zgqlBt/F1VNfGfDFwfEf8AiIjXOznGwjjRrj42B/4v9/4vqa3ZPhHxIbAQ2LhToqusmvi7srbG/1XgfwuNqG2qil/SaZLmAJcDZ3ZSbNWoGL+kXYEtI+L+zgysStX++zkq3Xq4U9KWnRNaVaqJf3tge0mPS3pK0kGdFl3BnGjNuhhJ/w7UA1fUOpa2iojrI2Jb4FzgglrHUy1JawD/DfxXrWNZCfcCdRGxM/AQy1enuos1yZaP9wGOA26StFFNI+ogTrSrj1eB/E+4W6S2ZvtIWhPoDbzZKdFVVk38XVlV8Us6APg2cFhELO2k2KrR1s//N8ARhUbUNpXi3wAYBEyQ9DKwGzCuCz0QVfHzj4g3c/9mfgoM7aTYqlHNv5+/AOMi4oOImAe8QJZ4uz0n2tXHM0B/SVtLWpvsYadxZX3GAV9J20cDj0R6KqELqCb+rqxi/JJ2AW4kS7Jd7f5UNfHn/6d4MPBiJ8ZXSavxR8TCiNgkIuoioo7sHvlhEdFQm3A/oprPv2/u7WHAc50YXyXV/Pd7D9lsFkmbkC0lz+3MIAtT66ex/Oq8F/BvZD8lzgG+ndq+T/Y/FICewB3AS8AkYJtax9zG+IeR/VT8LtlMfGatY25j/H8E5gNT02tcrWNuY/zXADNT7OOBgbWOuS3xl/WdQBd66rjKz/+S9PlPS5//gFrH3Mb4RbZ8PwtoBI6tdcwd9fI3Q5mZmRXIS8dmZmYFcqI1MzMrkBOtmZlZgZxozczMCuREa2ZmViAnWjMzswI50ZqZmRXIidbMzKxA/x+hrt3d47D/4AAAAABJRU5ErkJggg==\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": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature: 0, Score: 0.66263\n",
      "Feature: 1, Score: 0.01316\n",
      "Feature: 2, Score: 0.20480\n",
      "Feature: 3, Score: 0.00254\n",
      "Feature: 4, Score: 0.02834\n",
      "Feature: 5, Score: 0.01281\n",
      "Feature: 6, Score: 0.01971\n",
      "Feature: 7, Score: 0.02451\n",
      "Feature: 8, Score: 0.00960\n",
      "Feature: 9, Score: 0.01757\n",
      "Feature: 10, Score: 0.00434\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": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "import xgboost as xgb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "kf = KFold(n_splits=5)\n",
    "kf.get_n_splits(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('TRAIN:', array([171369, 171370, 171371, ..., 856839, 856840, 856841]), 'TEST:', array([     0,      1,      2, ..., 171366, 171367, 171368]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 1.069214739883615)\n",
      "('Mean Squared Error of XGBoost Kfold:', 154.70359592565612)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 12.437990027558959)\n",
      "('TRAIN:', array([     0,      1,      2, ..., 856839, 856840, 856841]), 'TEST:', array([171369, 171370, 171371, ..., 342735, 342736, 342737]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 0.21203553795192623)\n",
      "('Mean Squared Error of XGBoost Kfold:', 4.794624945457326)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 2.1896632036588017)\n",
      "('TRAIN:', array([     0,      1,      2, ..., 856839, 856840, 856841]), 'TEST:', array([342738, 342739, 342740, ..., 514103, 514104, 514105]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 0.2237591238726402)\n",
      "('Mean Squared Error of XGBoost Kfold:', 14.46336676285411)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 3.803073331248572)\n",
      "('TRAIN:', array([     0,      1,      2, ..., 856839, 856840, 856841]), 'TEST:', array([514106, 514107, 514108, ..., 685471, 685472, 685473]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 0.24571659228313225)\n",
      "('Mean Squared Error of XGBoost Kfold:', 36.40306259618478)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 6.033495056448193)\n",
      "('TRAIN:', array([     0,      1,      2, ..., 685471, 685472, 685473]), 'TEST:', array([685474, 685475, 685476, ..., 856839, 856840, 856841]))\n",
      "('Mean Absolute Error of XGBoost Kfold:', 0.3817835868945418)\n",
      "('Mean Squared Error of XGBoost Kfold:', 28.48175679432794)\n",
      "('Root Mean Squared Error of XGBoost Kfold:', 5.336830219739798)\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": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Mean RMSE is :', 5.960210367730864)\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": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "importances = regressor.feature_importances_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7fe9f3cda050>"
      ]
     },
     "execution_count": 46,
     "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": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Feature: 0, Score: 0.47184\n",
      "Feature: 1, Score: 0.05384\n",
      "Feature: 2, Score: 0.10847\n",
      "Feature: 3, Score: 0.01826\n",
      "Feature: 4, Score: 0.04840\n",
      "Feature: 5, Score: 0.10538\n",
      "Feature: 6, Score: 0.02249\n",
      "Feature: 7, Score: 0.08801\n",
      "Feature: 8, Score: 0.04516\n",
      "Feature: 9, Score: 0.02519\n",
      "Feature: 10, Score: 0.01294\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": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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
}