02_model_selection.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Initial model selection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import svm\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.metrics import jaccard_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def flatten(container):\n",
    "    \"Flattens lists\"\n",
    "    for i in container:\n",
    "        if isinstance(i, (list, tuple)):\n",
    "            for j in flatten(i):\n",
    "                yield j\n",
    "        else:\n",
    "            yield i\n",
    "\n",
    "def feature_list(no_of_neighbors):\n",
    "    \"\"\"\n",
    "    Creates a list of features given number of adjacent wells\n",
    "    param no_of_neighbors: number of adjacent wells used in feature engineering\n",
    "    \"\"\"\n",
    "    print(\"Getting the features\")\n",
    "    initial = [\"thickness\", \"thickness natural log\", \"thickness power\"]\n",
    "    features = []\n",
    "    for item in initial:\n",
    "        features.append(item)\n",
    "        for i in range(1, no_of_neighbors + 1):\n",
    "            features.append(item + \" neighbor \" + str(i))\n",
    "    features.append([\"x location\", \"y location\", \"class\"])\n",
    "    return list(flatten(features))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### read in the synthetic training data and select a subset with the wells in the local vicinity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Getting the features\n"
    }
   ],
   "source": [
    "dataset = pd.read_csv(r'stratigraphic_geometry_dataset.csv', index_col=[0])\n",
    "\n",
    "# Set number of wells in vicinity\n",
    "wells_in_vicinity = 0\n",
    "flat_features = feature_list(wells_in_vicinity)\n",
    "\n",
    "subset = dataset[flat_features]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### split into train and test subsets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(\n",
    "        subset.drop(\"class\", axis=1), subset[\"class\"], test_size=0.2, random_state=86,\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### train and score the SVM classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Accuracy for each class is [0.75636212 0.48589126 0.30998249]\nAverage weighted accuracy is 0.52\n"
    }
   ],
   "source": [
    "# SVM\n",
    "svmclf = svm.SVC()\n",
    "svmclf.fit(X_train, y_train)\n",
    "y_pred = svmclf.predict(X_test)\n",
    "weighted_jc_score = jaccard_score(y_test, y_pred, average='weighted')\n",
    "print(f'Accuracy for each class is {jaccard_score(y_test, y_pred, average=None)}')\n",
    "print(f'Average weighted accuracy is {weighted_jc_score:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### train and score the decision tree classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Accuracy for each class is [0.92240493 0.72088966 0.73125565]\nAverage weighted accuracy is 0.79\n"
    }
   ],
   "source": [
    "# Decision Tree\n",
    "dtclf = DecisionTreeClassifier()\n",
    "dtclf.fit(X_train, y_train)\n",
    "y_pred = dtclf.predict(X_test)\n",
    "weighted_jc_score = jaccard_score(y_test, y_pred, average='weighted')\n",
    "print(f'Accuracy for each class is {jaccard_score(y_test, y_pred, average=None)}')\n",
    "print(f'Average weighted accuracy is {weighted_jc_score:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### train and score the random forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Accuracy for each class is [0.93062693 0.76422018 0.77320054]\nAverage weighted accuracy is 0.82\n"
    }
   ],
   "source": [
    "# Random Forest\n",
    "rfclf = RandomForestClassifier()\n",
    "rfclf.fit(X_train, y_train)\n",
    "y_pred = rfclf.predict(X_test)\n",
    "weighted_jc_score = jaccard_score(y_test, y_pred, average='weighted')\n",
    "print(f'Accuracy for each class is {jaccard_score(y_test, y_pred, average=None)}')\n",
    "print(f'Average weighted accuracy is {weighted_jc_score:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### train and score adaboost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Accuracy for each class is [0.7580574  0.36306672 0.39484199]\nAverage weighted accuracy is 0.50\n"
    }
   ],
   "source": [
    "# AdaBoost\n",
    "abclf = AdaBoostClassifier()\n",
    "abclf.fit(X_train, y_train)\n",
    "y_pred = abclf.predict(X_test)\n",
    "weighted_jc_score = jaccard_score(y_test, y_pred, average='weighted')\n",
    "print(f'Accuracy for each class is {jaccard_score(y_test, y_pred, average=None)}')\n",
    "print(f'Average weighted accuracy is {weighted_jc_score:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### train and score the KNN classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "Accuracy for each class is [0.72285464 0.58974359 0.53508412]\nAverage weighted accuracy is 0.61\n"
    }
   ],
   "source": [
    "# KNN\n",
    "knclf = KNeighborsClassifier()\n",
    "knclf.fit(X_train, y_train)\n",
    "y_pred = knclf.predict(X_test)\n",
    "weighted_jc_score = jaccard_score(y_test, y_pred, average='weighted')\n",
    "print(f'Accuracy for each class is {jaccard_score(y_test, y_pred, average=None)}')\n",
    "print(f'Average weighted accuracy is {weighted_jc_score:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3-final"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}