waterpumpspredictor.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "waterpumpspredictor.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyMKAMmc2z8vGSY2dTZtftNg",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/maxkleiner/maXbox/blob/master/waterpumpspredictor.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1-1-et9WOhOr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Preprocessor and Classifier for Water Pumps State, modified for Kaggle Competition by Max.\n",
        "# https://towardsdatascience.com/water-pumps-maintenance-prediction-data-science-illustrated-20c7100017c5\n",
        "# Licensed under the Apache License, Version 2.0 (the \"License\");  locs=277\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "import random\n",
        "import pdb\n",
        "import math\n",
        "import matplotlib.pyplot as plt\n",
        "from matplotlib.pylab import rcParams\n",
        "rcParams['figure.figsize'] = 10, 5\n",
        "import sklearn.model_selection #.train_test_split\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.preprocessing import LabelEncoder\n",
        "import sklearn.tree as dtreec\n",
        "import sklearn.ensemble as densemble\n",
        "from sklearn.model_selection import cross_validate   #Additional sklearn functions\n",
        "from sklearn.metrics import accuracy_score, roc_auc_score\n",
        "from sklearn.metrics import classification_report\n",
        "from sklearn.metrics import confusion_matrix\n",
        "import scipy.stats as ss\n"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "49_XgsIyPKjp",
        "colab_type": "text"
      },
      "source": [
        "Function Definitions:\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Kf6u92XLPRuL",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def transform_feature(df, column_name):\n",
        "    unique_values = set(df[column_name].tolist())\n",
        "    transformer_dict = {}\n",
        "    for index, value in enumerate(unique_values):\n",
        "        transformer_dict[value] = index\n",
        "    df[column_name] = df[column_name].apply(lambda y: transformer_dict[y])\n",
        "    return df\n",
        "\n",
        "def cramers_stat(confusion_matrix):\n",
        "    chi2 = ss.chi2_contingency(confusion_matrix)[0]\n",
        "    n = confusion_matrix.sum()\n",
        "    return np.sqrt(chi2 / (n*(min(confusion_matrix.shape)-1)))\n",
        "\n",
        "\n",
        "def batch_gen(X, batch_size):\n",
        "    n_batches = X.shape[0]/float(batch_size)\n",
        "    n_batches = int(math.ceil(n_batches))\n",
        "    end = int(X.shape[0]/float(batch_size)) * batch_size\n",
        "    n = 0\n",
        "    for i in range(0,n_batches):\n",
        "        if i < n_batches - 1: \n",
        "            batch = X[i*batch_size:(i+1) * batch_size, :]\n",
        "            yield batch\n",
        "        else:\n",
        "            batch = X[end: , :]\n",
        "            n += X[end:, :].shape[0]\n",
        "            yield batch\n",
        "        \n",
        "\n",
        "# Find columns with Null values\n",
        "def find_nullvalues(dfX):\n",
        "  nullcols = []\n",
        "  for col in dfX.columns:\n",
        "    nbnull = (dfX[col].isnull()*1).sum()\n",
        "    if ( nbnull > 0 ):\n",
        "        tp = type(dfX[dfX[col].notnull()][col].iat[0]) # type of first non null value\n",
        "        nullcols.append([col, tp])\n",
        "        print(col, nbnull, tp)\n",
        "\n",
        "def find_defaultvalues(dfX, numerics):\n",
        "  for col in numerics: # Check frequency of most common values\n",
        "    cs = dfX[col].value_counts(normalize=True, sort=True, ascending=False)\n",
        "    for k in cs.keys()[0:5]:\n",
        "        print( col, k, int(cs[k]*1000)/10. )\n",
        "\n",
        "def find_rarevaules(dfX, categories):\n",
        "    for col in categories:\n",
        "        cs = dfX[col].value_counts(normalize=False, sort=True, ascending=False)\n",
        "    rare_values = [k for k in cs.keys() if cs[k]<40] # Theshold = 40 occurrences\n",
        "    if len(rare_values)>0:\n",
        "        print( 'Trim values : ', col, len(rare_values))\n",
        "        dfX.loc[dfX[col].isin(rare_values), col] = col+'_rare'\n",
        "\n",
        "def find_mostvalues(dfX, dates):\n",
        "    for col in dates: \n",
        "    # Check frequency of most common values\n",
        "      cs = dfX[col].value_counts(normalize=True, sort=True, ascending=False)\n",
        "      for k in cs.keys()[0:5]:\n",
        "        print( col, k, int(cs[k]*10000)/100. )\n",
        "      print('')\n",
        "\n",
        "\n",
        "# Search for variables that are very similar and remove \"near duplicates\"\n",
        "def show_similars(df, cols, threshold=0.90):\n",
        "    for i1, col1 in enumerate(cols):\n",
        "        for i2, col2 in enumerate(cols):\n",
        "            if (i1<i2):\n",
        "                cm12 = pd.crosstab(df[col1], df[col2]).values # confusion matrix\n",
        "                #cv12 = cramers_corrected_stat(cm12) # WARNING : cramer V is a symetric stat ?\n",
        "                cv12 = cramers_stat(cm12) # compare to ?\n",
        "                if (cv12 > threshold):\n",
        "                    print((col1, col2), int(cv12*100))\n",
        "\n",
        "labels=['functional','functional needs repair','non functional']\n",
        "def plot_confusion_matrix(cm, title='Confusion matrix', cmap=plt.cm.Blues):\n",
        "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
        "    #plt.title(title)\n",
        "    plt.colorbar(shrink=0.7)\n",
        "    tick_marks = np.arange(len(labels))\n",
        "    plt.xticks(tick_marks, labels, rotation=45, ha='right', fontsize=12)\n",
        "    plt.yticks(tick_marks, labels , fontsize=12)\n",
        "    plt.tight_layout()\n",
        "    plt.ylabel('True label', fontsize=12)\n",
        "    plt.xlabel('Predicted label', fontsize=12)\n",
        "\n",
        "    if __name__ == \"__main__\":\n",
        "      X = np.random.rand(123, 32)\n",
        "      for batch in batch_gen(X, 21):\n",
        "        print (batch.shape)\n",
        "\n",
        "\n"
      ],
      "execution_count": 24,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hLkT0KndRDot",
        "colab_type": "text"
      },
      "source": [
        "This is an interesting dataset. The target variable consisted of three classes of water pumps: Functional, Non-function, and the ones that require repair work. This is a classic classification problem of how to accurately predict the classes. The challenge was if we can predict which pumps are functional. The dataset is decent size but requires some serious cleaning. Except for a few numerical variables, most of the features are categorical. The numeric features aren't very helpful given the number of missing values they have. However, they are important enough not to be thrown away. On the other hand, categorical variables don't have many missing values in comparison to numerical features, but almost each of them represents at least hundreds of categories."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HndZn_O6RGnn",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "a451a918-eccd-4eda-ac38-67828d81206a"
      },
      "source": [
        "train_values = pd.read_csv('https://s3.amazonaws.com/drivendata/data/7/public/4910797b-ee55-40a7-8668-10efd5c1b960.csv', encoding = 'iso-8859-1')\n",
        "train_labels = pd.read_csv('https://s3.amazonaws.com/drivendata/data/7/public/0bf8bc6e-30d0-4c50-956a-603fc693d966.csv', encoding = 'iso-8859-1')\n",
        "\n",
        "print(train_lables.info())\n",
        "train_df = train_values.merge(train_labels, on='id')\n",
        "\n",
        "# Drop by Columns status group  from dftrain Obj in place\n",
        "#train_labels = train_labels['status_group'=='functional']\n",
        "# train_df.drop(train_df[train_df.status_group=='functional needs repair'].index, inplace=True)\n",
        "train_values = train_df.iloc[:,0:39]\n",
        "train_labels = train_df.iloc[:,40:41]\n",
        "\n",
        "print('find null values_')\n",
        "find_nullvalues(train_values)\n",
        "\n",
        "numerics = ['amount_tsh', 'population']\n",
        "geos = ['gps_height','longitude','latitude','basin','subvillage','region','region_code','district_code','lga','ward']\n",
        "#dfX[geos].head(8)\n",
        "dates = ['date_recorded', 'construction_year']\n",
        "\n",
        "print('find default values_')\n",
        "find_defaultvalues(train_values, numerics)\n",
        "categories = [col for col in list(train_values.columns) \\\n",
        "                    if not(col in geos) and not(col in dates) and not (col in numerics)]\n",
        "categories.remove('id')\n",
        "\n",
        "print('find rare and most values_')\n",
        "# WARNING : \"construction_year\" is 0 for one-third of the records\n",
        "find_rarevaules(train_values, categories)\n",
        "dates = ['date_recorded', 'construction_year']\n",
        "find_mostvalues(train_values, dates)\n",
        "\n",
        "\n",
        "print(list(train_values.columns.values))\n",
        "print(train_labels.head(5))\n",
        "print(train_labels.status_group.value_counts())\n",
        "\n",
        "train_labels.status_group.value_counts().plot(title='Waterpumps_State', kind = 'bar')\n",
        "# train_labels.plot(x='status_group', kind = 'bar')\n",
        "plt.show()\n",
        "print(train_labels.status_group.count())\n",
        "print(train_labels.count())\n",
        "ylabels=train_labels['status_group'].value_counts()\n",
        "print(train_labels['status_group'].value_counts())\n",
        "train_labels['status_encoded'] = LabelEncoder().fit_transform(train_labels['status_group'])\n",
        "\n",
        "p = train_labels.reindex(columns=['0', '1', '2'])\n",
        "#train_labels.plot.pie(y=p.item(),figsize=(5, 5), autopct='%1.1f%%', startangle=90)\n",
        "#plt.show()\n",
        "\n",
        "#print(train_values.info())\n",
        "\n",
        "#train_df = train_values.merge(train_labels, on='id')\n",
        "print(train_df.info())\n",
        "\n",
        "#status_values = pd.factorize(train_labels['status_group'])\n",
        "#print(status_values[1])\n",
        "#status_valuesstr= str(['functional', 'non functional', 'functional needs repair'])\n",
        "piv_df= train_df[['basin','status_group','source']]\n",
        "piv_table = piv_df.pivot_table(index='basin',\n",
        "                           columns='status_group', aggfunc='count')\n",
        "print(piv_table)\n",
        "#piv_table.plot(title='water source status', kind = 'bar')\n",
        "#plt.show()\n",
        "\n",
        "# id can be droped because it is unique for each instance.\n",
        "train_values.drop('id',axis=1)\n",
        "# num_private is ~99% zeros\n",
        "train_values.drop('num_private',axis=1)\n",
        "# : we note that \"recorded_by\" only has 1 value so we discard this column\n",
        "train_values.drop('recorded_by', axis=1)\n",
        "\n",
        "\n",
        "integer_columns = ['days_since_recorded','population','gps_height'] \n",
        "columns_to_transform = [col for col in train_values if col not in integer_columns]\n",
        "for column in columns_to_transform: \n",
        "    X = transform_feature(train_values, column)\n",
        "    #y = transform_feature(train_labels, column)\n",
        "\n",
        "X_train, X_test, y_train, y_test = \\\n",
        "          sklearn.model_selection.train_test_split(X, train_labels, \n",
        "                                               test_size = 0.4, random_state = 0)  \n",
        "\n",
        "                                \n",
        "dtc = dtreec.DecisionTreeClassifier(criterion='gini',\n",
        "                             max_depth = 10,\n",
        "                             max_features = 'auto',\n",
        "                             random_state = 1,\n",
        "                             splitter = 'best')\n",
        "\n",
        "rfc = sklearn.ensemble.RandomForestClassifier(n_estimators=1000, \n",
        "                                               min_samples_split=6,\n",
        "                                               criterion='gini', \n",
        "                                               max_features='auto',\n",
        "                                               oob_score=True,\n",
        "                                               random_state=1,\n",
        "                                               n_jobs=-1)\n",
        "\n",
        "# Fit the algorithm on the data\n",
        "dtc.fit(X_train, y_train['status_group'])\n",
        "\n",
        "# Predict training set:\n",
        "dtrain_predictions = dtc.predict(X_test)\n",
        "dtrain_predprob = dtc.predict_proba(X_train)[:,1]\n",
        "\n",
        "# rint model report:\n",
        "target = 'status_group'\n",
        "#label=y_train[target].values\n",
        "label=y_test[target].values\n",
        "print (\"\\nModel Report Performance:\")\n",
        "print (\"Accuracy : %.4g\" % accuracy_score(label, dtrain_predictions))\n",
        "# print (\"AUC Score (Train): %f\" % roc_auc_score(label, dtrain_predprob))\n",
        "print(\"Train Score :\", dtc.score(X_train, y_train[target].values))\n",
        "print(\"Test Score :\", dtc.score(X_test, y_test[target].values))\n",
        "\n",
        "print(classification_report(digits=2, y_true=label, y_pred=dtrain_predictions))\n",
        "print(confusion_matrix(y_true=label, y_pred=dtrain_predictions))\n",
        "\n",
        "## Constructing the Confusion Matrix\n",
        "cm = confusion_matrix(label, dtrain_predictions)\n",
        "np.set_printoptions(precision=2)\n",
        "print('Confusion matrix')\n",
        "print(cm)\n",
        "plt.figure().suptitle('MaXtrix ', fontsize=12)\n",
        "plot_confusion_matrix(cm)\n",
        "plt.show()\n",
        "\n",
        "names=[]\n",
        "imps=[]\n",
        "for name, importance in sorted(zip(X_train.columns, dtc.feature_importances_),key=lambda x: x[1]):\n",
        "    #sorted(importance, key=lambda x: x[1])\n",
        "    names.append(name)\n",
        "    imps.append(importance)\n",
        "    print(name, importance)\n",
        "# Creating plot \n",
        "#print(name, importance)\n",
        "fig = plt.figure(figsize =(10, 7)) \n",
        "fig.suptitle('Most important features', fontsize=14)\n",
        "plt.pie(imps, labels = names)  \n",
        "plt.title='most important Features'  \n",
        "plt.show() \n",
        "#zipped = zip(name, importance)    \n",
        "#sorted(zipped, key=lambda x: x[1])\n",
        "    ## Now You Can Do Whatever You Want(plot them using a Barplot etc)\n",
        "\n",
        "# show_similars(train_values, ['basin','region','region_code','district_code','lga'], 0.95)\n",
        "#show_similars(['basin','region'], 0.95)\n",
        "print('')\n",
        "#show_similars(train_values, categories, 0.95)\n",
        "\n",
        "basics = ['amount_tsh','payment',\n",
        "          'population','installer','funder','source_type','quantity',\n",
        "          'construction_year', 'waterpoint_type', 'extraction_type',\n",
        "          'region_code','gps_height', 'lga', 'basin', 'district_code']\n",
        "\n",
        "LR = LogisticRegression(multi_class='ovr')\n",
        "LR.fit(X_train[basics].values, y_train[target].values)\n",
        "\n",
        "score = LR.score(X_test[basics].values, y_test[target].values)\n",
        "print(int(score*1000)/10)\n",
        "\n",
        "print('all classified runs to end, you know in the long run we''re all ...')\n",
        "\n",
        "\n",
        "\"\"\" DOC\n",
        "The group of features of (extraction_type, extraction_type_group, extraction_type_class), (payment, payment_type),\n",
        "(water_quality, quality_group), (source, source_class), (subvillage, region, region_code, district_code, lga, ward), and (waterpoint_type, waterpoint_type_group) all contain similar representation of data in different grains. Hence, we risk overfitting our data during training by including all the features in our analysis, which can be dropped.\n",
        "\n",
        "    id can be droped because it is unique for each instance.\n",
        "    num_private is ~99% zeros\n",
        "https://towardsdatascience.com/predicting-the-functional-status-of-pumps-in-tanzania-355c9269d0c2\n",
        "\n",
        "Project Location:\n",
        "\n",
        "https://github.com/ksdkalluri/identifying_faulty_pumps\n",
        "\n",
        "https://github.com/mzaradzki/hft-statistical-learning/blob/master/pump_it_up/pump.ipynb\n",
        "\n",
        "from sklearn.tree import export_graphviz\n",
        "import graphviz\n",
        "\n",
        "export_graphviz(tree, out_file=\"mytree.dot\")\n",
        "with open(\"mytree.dot\") as f:\n",
        "    dot_graph = f.read()\n",
        "graphviz.Source(dot_graph)\n",
        "\n",
        "waterpoint_type 0.051179038270807505\n",
        "construction_year 0.05351109516427301\n",
        "extraction_type 0.1402774970807472\n",
        "quantity_group 0.14924450776263562\n",
        "quantity 0.2215791028642887\n",
        "\n",
        "  return np.sqrt(chi2 / (n*(min(confusion_matrix.shape)-1)))\n",
        "('extraction_type', 'extraction_type_group') 100\n",
        "('extraction_type', 'extraction_type_class') 100\n",
        "('extraction_type_group', 'extraction_type_class') 100\n",
        "('management', 'management_group') 100\n",
        "('payment', 'payment_type') 100\n",
        "('water_quality', 'quality_group') 100\n",
        "('quantity', 'quantity_group') 100\n",
        "('source', 'source_type') 100\n",
        "('source', 'source_class') 100\n",
        "('source_type', 'source_class') 100\n",
        "\n",
        "https://datascience.stackexchange.com/questions/28574/decisiontreeclassifier-object-has-no-attribute-importances\n",
        "\n",
        "importance = dtc.feature_importances_\n",
        "importance = pd.DataFrame(importance, index=train_values.columns, \n",
        "                          columns=[\"Importance\"])\n",
        "importance[\"Std\"] = np.std([tree.feature_importances_ \n",
        "                            for tree in dtc.estimators_], axis=0)\n",
        "\n",
        "x = range(importance.shape[0])\n",
        "y = importance.iloc[:, 0]\n",
        "yerr = importance.iloc[:, 1]\n",
        "lables = list(train_values.columns.values)\n",
        "ax = plt.bar(x, y, yerr=yerr ,align=\"center\")\n",
        "plt.xlabel('Features', fontsize = 12)\n",
        "plt.ylabel('Importance', fontsize = 12)\n",
        "\n",
        "\n",
        "\n",
        "\"\"\"    "
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'pandas.core.frame.DataFrame'>\n",
            "RangeIndex: 59400 entries, 0 to 59399\n",
            "Data columns (total 2 columns):\n",
            " #   Column        Non-Null Count  Dtype \n",
            "---  ------        --------------  ----- \n",
            " 0   id            59400 non-null  int64 \n",
            " 1   status_group  59400 non-null  object\n",
            "dtypes: int64(1), object(1)\n",
            "memory usage: 928.2+ KB\n",
            "None\n",
            "find null values_\n",
            "funder 3635 <class 'str'>\n",
            "installer 3655 <class 'str'>\n",
            "subvillage 371 <class 'str'>\n",
            "public_meeting 3334 <class 'bool'>\n",
            "scheme_management 3877 <class 'str'>\n",
            "scheme_name 28166 <class 'str'>\n",
            "permit 3056 <class 'bool'>\n",
            "find default values_\n",
            "amount_tsh 0.0 70.0\n",
            "amount_tsh 500.0 5.2\n",
            "amount_tsh 50.0 4.1\n",
            "amount_tsh 1000.0 2.5\n",
            "amount_tsh 20.0 2.4\n",
            "population 0 35.9\n",
            "population 1 11.8\n",
            "population 200 3.2\n",
            "population 150 3.1\n",
            "population 250 2.8\n",
            "find rare and most values_\n",
            "Trim values :  waterpoint_type 1\n",
            "date_recorded 2011-03-15 0.96\n",
            "date_recorded 2011-03-17 0.93\n",
            "date_recorded 2013-02-03 0.91\n",
            "date_recorded 2011-03-14 0.87\n",
            "date_recorded 2011-03-16 0.86\n",
            "\n",
            "construction_year 0 34.86\n",
            "construction_year 2010 4.45\n",
            "construction_year 2008 4.39\n",
            "construction_year 2009 4.26\n",
            "construction_year 2000 3.52\n",
            "\n",
            "['id', 'amount_tsh', 'date_recorded', 'funder', 'gps_height', 'installer', 'longitude', 'latitude', 'wpt_name', 'num_private', 'basin', 'subvillage', 'region', 'region_code', 'district_code', 'lga', 'ward', 'population', 'public_meeting', 'recorded_by', 'scheme_management', 'scheme_name', 'permit', 'construction_year', 'extraction_type', 'extraction_type_group', 'extraction_type_class', 'management', 'management_group', 'payment', 'payment_type', 'water_quality', 'quality_group', 'quantity', 'quantity_group', 'source', 'source_type', 'source_class', 'waterpoint_type']\n",
            "     status_group\n",
            "0      functional\n",
            "1      functional\n",
            "2      functional\n",
            "3  non functional\n",
            "4      functional\n",
            "functional                 32259\n",
            "non functional             22824\n",
            "functional needs repair     4317\n",
            "Name: status_group, dtype: int64\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x360 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "59400\n",
            "status_group    59400\n",
            "dtype: int64\n",
            "functional                 32259\n",
            "non functional             22824\n",
            "functional needs repair     4317\n",
            "Name: status_group, dtype: int64\n",
            "<class 'pandas.core.frame.DataFrame'>\n",
            "Int64Index: 59400 entries, 0 to 59399\n",
            "Data columns (total 41 columns):\n",
            " #   Column                 Non-Null Count  Dtype  \n",
            "---  ------                 --------------  -----  \n",
            " 0   id                     59400 non-null  int64  \n",
            " 1   amount_tsh             59400 non-null  float64\n",
            " 2   date_recorded          59400 non-null  object \n",
            " 3   funder                 55765 non-null  object \n",
            " 4   gps_height             59400 non-null  int64  \n",
            " 5   installer              55745 non-null  object \n",
            " 6   longitude              59400 non-null  float64\n",
            " 7   latitude               59400 non-null  float64\n",
            " 8   wpt_name               59400 non-null  object \n",
            " 9   num_private            59400 non-null  int64  \n",
            " 10  basin                  59400 non-null  object \n",
            " 11  subvillage             59029 non-null  object \n",
            " 12  region                 59400 non-null  object \n",
            " 13  region_code            59400 non-null  int64  \n",
            " 14  district_code          59400 non-null  int64  \n",
            " 15  lga                    59400 non-null  object \n",
            " 16  ward                   59400 non-null  object \n",
            " 17  population             59400 non-null  int64  \n",
            " 18  public_meeting         56066 non-null  object \n",
            " 19  recorded_by            59400 non-null  object \n",
            " 20  scheme_management      55523 non-null  object \n",
            " 21  scheme_name            31234 non-null  object \n",
            " 22  permit                 56344 non-null  object \n",
            " 23  construction_year      59400 non-null  int64  \n",
            " 24  extraction_type        59400 non-null  object \n",
            " 25  extraction_type_group  59400 non-null  object \n",
            " 26  extraction_type_class  59400 non-null  object \n",
            " 27  management             59400 non-null  object \n",
            " 28  management_group       59400 non-null  object \n",
            " 29  payment                59400 non-null  object \n",
            " 30  payment_type           59400 non-null  object \n",
            " 31  water_quality          59400 non-null  object \n",
            " 32  quality_group          59400 non-null  object \n",
            " 33  quantity               59400 non-null  object \n",
            " 34  quantity_group         59400 non-null  object \n",
            " 35  source                 59400 non-null  object \n",
            " 36  source_type            59400 non-null  object \n",
            " 37  source_class           59400 non-null  object \n",
            " 38  waterpoint_type        59400 non-null  object \n",
            " 39  waterpoint_type_group  59400 non-null  object \n",
            " 40  status_group           59400 non-null  object \n",
            "dtypes: float64(3), int64(7), object(31)\n",
            "memory usage: 19.0+ MB\n",
            "None\n",
            "                            source                                       \n",
            "status_group            functional functional needs repair non functional\n",
            "basin                                                                    \n",
            "Internal                      4482                     557           2746\n",
            "Lake Nyasa                    3324                     250           1511\n",
            "Lake Rukwa                    1000                     270           1184\n",
            "Lake Tanganyika               3107                     742           2583\n",
            "Lake Victoria                 5100                     989           4159\n",
            "Pangani                       5372                     477           3091\n",
            "Rufiji                        5068                     437           2471\n",
            "Ruvuma / Southern Coast       1670                     326           2497\n",
            "Wami / Ruvu                   3136                     269           2582\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:44: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame.\n",
            "Try using .loc[row_indexer,col_indexer] = value instead\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Model Report Performance:\n",
            "Accuracy : 0.7374\n",
            "Train Score : 0.7635802469135803\n",
            "Test Score : 0.7374158249158249\n",
            "                         precision    recall  f1-score   support\n",
            "\n",
            "             functional       0.71      0.90      0.80     12841\n",
            "functional needs repair       0.52      0.15      0.24      1746\n",
            "         non functional       0.81      0.62      0.70      9173\n",
            "\n",
            "               accuracy                           0.74     23760\n",
            "              macro avg       0.68      0.56      0.58     23760\n",
            "           weighted avg       0.74      0.74      0.72     23760\n",
            "\n",
            "[[11569   128  1144]\n",
            " [ 1282   266   198]\n",
            " [ 3373   114  5686]]\n",
            "Confusion matrix\n",
            "[[11569   128  1144]\n",
            " [ 1282   266   198]\n",
            " [ 3373   114  5686]]\n",
            "(21, 32)\n",
            "(21, 32)\n",
            "(21, 32)\n",
            "(21, 32)\n",
            "(21, 32)\n",
            "(18, 32)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x360 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "num_private 0.0\n",
            "recorded_by 0.0\n",
            "quality_group 0.0013805028900443236\n",
            "water_quality 0.0027250851874984616\n",
            "longitude 0.00413490995980675\n",
            "quantity_group 0.004310736362021385\n",
            "management_group 0.00440160996143544\n",
            "latitude 0.004573652010186108\n",
            "subvillage 0.004957786278901184\n",
            "wpt_name 0.005135646733252982\n",
            "id 0.005348201874962109\n",
            "ward 0.006698945371065279\n",
            "permit 0.006786025280208736\n",
            "public_meeting 0.006786448855378314\n",
            "amount_tsh 0.007146021251804273\n",
            "management 0.007329513083450694\n",
            "source_class 0.00739259265351751\n",
            "scheme_management 0.007459712706460156\n",
            "date_recorded 0.00775461337061254\n",
            "extraction_type_group 0.00968029962819629\n",
            "region 0.009801880702022753\n",
            "source 0.010682895362053751\n",
            "source_type 0.010797037329814784\n",
            "gps_height 0.010984372834409142\n",
            "population 0.014398317601102837\n",
            "region_code 0.014614014177603194\n",
            "district_code 0.016148144784015248\n",
            "scheme_name 0.017383365518691678\n",
            "payment_type 0.018532931710291505\n",
            "construction_year 0.020973488891978108\n",
            "installer 0.021012539824370704\n",
            "funder 0.02143810124729992\n",
            "basin 0.029066379210162634\n",
            "extraction_type_class 0.03674157275726187\n",
            "lga 0.03878620336105113\n",
            "payment 0.05928884911424784\n",
            "extraction_type 0.08959364674231939\n",
            "waterpoint_type 0.09457918348971638\n",
            "quantity 0.3611747718827845\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 720x504 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
            "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
            "\n",
            "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
            "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
            "Please also refer to the documentation for alternative solver options:\n",
            "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
            "  extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n",
            "/usr/local/lib/python3.6/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
            "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
            "\n",
            "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
            "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
            "Please also refer to the documentation for alternative solver options:\n",
            "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
            "  extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "62.2\n",
            "all classified runs to end, you know in the long run were all ...\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\n",
            "STOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n",
            "\n",
            "Increase the number of iterations (max_iter) or scale the data as shown in:\n",
            "    https://scikit-learn.org/stable/modules/preprocessing.html\n",
            "Please also refer to the documentation for alternative solver options:\n",
            "    https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n",
            "  extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic": {
              "type": "string"
            },
            "text/plain": [
              "' DOC\\nThe group of features of (extraction_type, extraction_type_group, extraction_type_class), (payment, payment_type),\\n(water_quality, quality_group), (source, source_class), (subvillage, region, region_code, district_code, lga, ward), and (waterpoint_type, waterpoint_type_group) all contain similar representation of data in different grains. Hence, we risk overfitting our data during training by including all the features in our analysis, which can be dropped.\\n\\n    id can be droped because it is unique for each instance.\\n    num_private is ~99% zeros\\nhttps://towardsdatascience.com/predicting-the-functional-status-of-pumps-in-tanzania-355c9269d0c2\\n\\nProject Location:\\n\\nhttps://github.com/ksdkalluri/identifying_faulty_pumps\\n\\nhttps://github.com/mzaradzki/hft-statistical-learning/blob/master/pump_it_up/pump.ipynb\\n\\nfrom sklearn.tree import export_graphviz\\nimport graphviz\\n\\nexport_graphviz(tree, out_file=\"mytree.dot\")\\nwith open(\"mytree.dot\") as f:\\n    dot_graph = f.read()\\ngraphviz.Source(dot_graph)\\n\\nwaterpoint_type 0.051179038270807505\\nconstruction_year 0.05351109516427301\\nextraction_type 0.1402774970807472\\nquantity_group 0.14924450776263562\\nquantity 0.2215791028642887\\n\\n  return np.sqrt(chi2 / (n*(min(confusion_matrix.shape)-1)))\\n(\\'extraction_type\\', \\'extraction_type_group\\') 100\\n(\\'extraction_type\\', \\'extraction_type_class\\') 100\\n(\\'extraction_type_group\\', \\'extraction_type_class\\') 100\\n(\\'management\\', \\'management_group\\') 100\\n(\\'payment\\', \\'payment_type\\') 100\\n(\\'water_quality\\', \\'quality_group\\') 100\\n(\\'quantity\\', \\'quantity_group\\') 100\\n(\\'source\\', \\'source_type\\') 100\\n(\\'source\\', \\'source_class\\') 100\\n(\\'source_type\\', \\'source_class\\') 100\\n\\nhttps://datascience.stackexchange.com/questions/28574/decisiontreeclassifier-object-has-no-attribute-importances\\n\\nimportance = dtc.feature_importances_\\nimportance = pd.DataFrame(importance, index=train_values.columns, \\n                          columns=[\"Importance\"])\\nimportance[\"Std\"] = np.std([tree.feature_importances_ \\n                            for tree in dtc.estimators_], axis=0)\\n\\nx = range(importance.shape[0])\\ny = importance.iloc[:, 0]\\nyerr = importance.iloc[:, 1]\\nlables = list(train_values.columns.values)\\nax = plt.bar(x, y, yerr=yerr ,align=\"center\")\\nplt.xlabel(\\'Features\\', fontsize = 12)\\nplt.ylabel(\\'Importance\\', fontsize = 12)\\n\\n\\n\\n'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 26
        }
      ]
    }
  ]
}