analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# Assessment criteria\n",
    "\n",
    "Is the code well commented and easy to follow?\n",
    "Is it consistent (i.e. consistent names for\n",
    "variables, functions, etc.)? does it use informative\n",
    "names for variables and functions? Does it give\n",
    "the results as stated in the paper?\n",
    "\n",
    "# Todo:\n",
    "Outliers for string columns and population\n",
    "Imputation - for population and amount_tsh\n",
    "Normalisation/standardisation\n",
    "Fancy graphs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Preamble/imports\n",
    "import pandas as pd # for df manipulation\n",
    "import numpy as np # for additional data analysis functionality\n",
    "import missingno as msno # for missing number analysis\n",
    "import seaborn as sns # for data visualisation\n",
    "import matplotlib.pyplot as plt # for data visualisation\n",
    "import datetime as dt # for manipulation of the date column\n",
    "from sklearn import linear_model # For regression analysis\n",
    "import copy # for deep copying the dataset class, so we can have both joint and separate analysis\n",
    "from sklearn.decomposition import PCA # For Principal Component Analysis\n",
    "\n",
    "# JB's imports for the geographical graph\n",
    "import geopandas as gpd\n",
    "import descartes\n",
    "from shapely.geometry import Point, Polygon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_dep_var = pd.read_csv('Training set labels.csv') # , index_col=0\n",
    "training_indep_vars = pd.read_csv('Training set values.csv')\n",
    "training_df = training_dep_var.merge(training_indep_vars, on='id')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "test_df = pd.read_csv('Test set values.csv') # , index_col=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_62906/2464380950.py:3: FutureWarning: In future versions `DataFrame.to_latex` is expected to utilise the base implementation of `Styler.to_latex` for formatting and rendering. The arguments signature may therefore change. It is recommended instead to use `DataFrame.style.to_latex` which also contains additional functionality.\n",
      "  tf.write(training_df.loc[:, training_df.columns != 'id'].describe().round(1).to_latex(float_format=\"{:.1f}\".format))\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Export summary stats to tex\n",
    "with open('Output/summary_stats.tex','w') as tf:\n",
    "    tf.write(training_df.loc[:, training_df.columns != 'id'].describe().round(1).to_latex(float_format=\"{:.1f}\".format))\n",
    "\n",
    "# Export dep_var bar graph\n",
    "sns.countplot(data=training_df, x=\"status_group\").set_title('Distribution of the dependent variable (pump status)')\n",
    "plt.savefig('Output/dep_var.png', dpi=1200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dataset:\n",
    "    def __init__(self, data, training_data=None):\n",
    "        self.df = data.copy()\n",
    "        self.ids = self.df['id']\n",
    "        self.nans_col = 'NaNs'\n",
    "        self.dep_var = 'status_group'\n",
    "        self.cat_cols = ['funder', 'installer', 'basin', 'region', 'permit', 'extraction_type_class', 'management_group', 'payment_type', 'water_quality', 'quantity', 'source']\n",
    "        self.training_data = training_data\n",
    "\n",
    "    def convert_datetime(self):\n",
    "        # Initial cleaning\n",
    "        self.df['date_recorded'] = pd.to_datetime(self.df['date_recorded']) # Convert dates to datetime\n",
    "\n",
    "    def convert_missing_values(self, training_data=True): # Braganza and Pointon\n",
    "        # Missing values\n",
    "        self.df.loc[self.df['longitude']==0.0, 'longitude'] = np.nan # incorrect values\n",
    "        self.df.loc[self.df['latitude']==-2.000000e-08, 'latitude'] = np.nan # incorrect values\n",
    "        self.df.loc[self.df['gps_height']==0, 'gps_height'] = np.nan # very likely to be incorrect\n",
    "        self.df.loc[self.df['construction_year']==0, 'construction_year'] = np.nan # incorrect values\n",
    "        self.df.loc[(self.df['population']==0), 'population'] = np.nan # very likely to be incorrect # & (df['status_group']!='non functional')\n",
    "        self.df.loc[(self.df['population']>50000), 'population'] = np.nan # very likely to be incorrect\n",
    "        # self.df[self.df['installer'].str.contains(\"gov\")].value_counts('installer')\n",
    "        self.df.loc[self.df['installer']=='0', 'installer'] = np.nan # very likely to be incorrect\n",
    "        self.df.loc[self.df['installer']=='-', 'installer'] = np.nan # functional change\n",
    "        self.df.loc[self.df['funder']=='0', 'funder'] = 'unknown' # very likely to be incorrect\n",
    "        self.df['gps_height'] = abs(self.df['gps_height']) # incorrect as per https://www.cia.gov/the-world-factbook/countries/tanzania/\n",
    "        self.df.loc[self.df['amount_tsh']>400, 'amount_tsh'] = np.nan # very likely to be incorrect\n",
    "        self.df.loc[self.df['date_recorded']<pd.Timestamp(2010, 1, 1), 'date_recorded'] = self.df.loc[self.df['date_recorded']<pd.Timestamp(2010, 1, 1), 'date_recorded'] + pd.offsets.DateOffset(years=10) # any dates before 2010 are wrong and probably 10 years out due to a typo...\n",
    "\n",
    "        if training_data:\n",
    "            self.df.loc[(self.df['amount_tsh']==0) & (self.df['status_group']=='functional'), 'amount_tsh'] = np.nan # very likely to be incorrect\n",
    "            self.df.loc[(self.df['amount_tsh']==0) & (self.df['status_group']=='non functional'), 'amount_tsh'] = np.nan # very likely to be incorrect\n",
    "\n",
    "    def convert_missing_to_unkown(self):\n",
    "        # Converting NaNs to 'unknown'\n",
    "        # Bool cols\n",
    "        self.df['permit'] = self.df['permit'].astype(str)\n",
    "        self.df.loc[(self.df['permit']!='True') & (self.df['permit']!='False'), 'permit'] = 'unknown' # replace NaN to keep it in the dataset\n",
    "        self.df['public_meeting'] = self.df['public_meeting'].astype(str)\n",
    "        self.df.loc[(self.df['public_meeting']!='True') & (self.df['public_meeting']!='False'), 'public_meeting'] = 'unknown' # replace NaN to keep it in the dataset\n",
    "        # Other cols\n",
    "        self.df.loc[pd.isnull(self.df['funder']), 'funder'] = 'unknown'\n",
    "        self.df.loc[pd.isnull(self.df['installer']), 'installer'] = 'unknown'\n",
    "\n",
    "    # def create_new_attributes(self):\n",
    "    #     # Attribute creation/manipulation\n",
    "    #     self.df['age'] = self.df['date_recorded'].dt.year-self.df['construction_year'] # create age col - keep as float due to no NaN representation for ints\n",
    "\n",
    "    def convert_lowercase(self):\n",
    "        # Convert everything to lowercase to remove case errors\n",
    "        for col in self.df.columns:\n",
    "            if self.df[col].dtype==object: # and col not in ['public_meeting']\n",
    "                self.df[col] = self.df[col].str.lower()\n",
    "\n",
    "    def group_infrequent_occurances(self):\n",
    "        # Grouping together infrequent occurances\n",
    "        self.df['funder_counts'] = self.df.groupby(['funder'])['funder'].transform('count')\n",
    "        self.df['installer_counts'] = self.df.groupby(['installer'])['installer'].transform('count')\n",
    "        self.df.loc[self.df['installer']=='central government', 'installer'] = 'government'\n",
    "        self.df.loc[self.df['installer']=='gover', 'installer'] = 'government'\n",
    "        self.df.loc[self.df['installer_counts']<400, 'installer'] = 'other' # Causes issues with test dataset as this number is fixed\n",
    "        self.df.loc[self.df['funder_counts']<400, 'funder'] = 'other' # Same here\n",
    "\n",
    "    def encode_dep_var(self):\n",
    "        # Do we want to do these?\n",
    "        self.df['status_group_encoding'] = self.df['status_group'].replace(\"non functional\", 0)\n",
    "        self.df['status_group_encoding'].replace(\"functional needs repair\", 1, inplace=True)\n",
    "        self.df['status_group_encoding'].replace(\"functional\", 2, inplace=True)\n",
    "        # self.df.drop(columns=['status_group'], inplace=True)\n",
    "\n",
    "    def drop_unnecessary_cols(self):\n",
    "        # Dropping quality_group as water_quality seems better! Same for source/type/class - generally the smalled subgroups have different distributions (more non-functional pumps!!)\n",
    "        self.df.drop(columns=['id', 'recorded_by', 'region_code', 'district_code', 'funder_counts', 'installer_counts', 'payment', 'quality_group', 'quantity_group', 'source_type', 'source_class', 'waterpoint_type', 'extraction_type_group', 'extraction_type', 'num_private', 'wpt_name', 'scheme_name', 'scheme_management', 'management', 'public_meeting'], inplace=True) # wpt_name, num_private,\n",
    "        # df.rename(columns={'payment_type': 'payment'})\n",
    "\n",
    "    def update_nans_col(self):\n",
    "        self.df[self.nans_col] = self.df.isna().sum(1)\n",
    "\n",
    "    def remove_dups(self):\n",
    "        # Finding dups\n",
    "        self.update_nans_col()\n",
    "        non_dup_criteria = ['id', self.nans_col, 'amount_tsh', 'gps_height', 'population', 'construction_year', 'permit', 'funder', 'installer', 'date_recorded'] # By including 'date_recorded', this means that any similar ones with different dates are counted as dups and therefore deleted\n",
    "        dup_criteria = [e for e in self.df.columns.tolist() if e not in non_dup_criteria]\n",
    "        dups = self.df[self.df.duplicated(keep=False, subset=dup_criteria)].sort_values(by=dup_criteria+[self.nans_col])\n",
    "\n",
    "        # Removing dups\n",
    "        self.df.sort_values(by=dup_criteria+[self.nans_col], inplace=True)\n",
    "        self.df.drop_duplicates(subset=dup_criteria, keep='first', inplace=True) # 104 dups\n",
    "        # df.sort_values(nans_col, ascending=False)\n",
    "\n",
    "    def sort_index(self):\n",
    "        #sorts index in ascending order and updates it\n",
    "        self.df.sort_index(inplace=True)\n",
    "        #delete current index and replace with numeric index\n",
    "        self.df.reset_index(drop=True, inplace=True)\n",
    "\n",
    "    def initial_cleaning(self, training_data=True):\n",
    "        self.convert_datetime()\n",
    "        self.convert_missing_values(training_data=training_data)\n",
    "        self.convert_missing_to_unkown()\n",
    "        # self.create_new_attributes()\n",
    "        self.convert_lowercase()\n",
    "        self.group_infrequent_occurances()\n",
    "        self.drop_unnecessary_cols()\n",
    "        if training_data:\n",
    "            self.encode_dep_var()\n",
    "            self.remove_dups()\n",
    "        self.sort_index()\n",
    "\n",
    "    def long_lat_imputation(self): # Pointon\n",
    "        # Imputation\n",
    "        # Using a shapefile to approximate GPS data by ward\n",
    "        ward_shape_file = gpd.read_file('2012 Wards Shapefiles/TZwards.shp') # from https://data.humdata.org/dataset/cod-ab-tza\n",
    "        ward_shape_file['approx_longitude'] = ward_shape_file.centroid.x\n",
    "        ward_shape_file['approx_latitude'] = ward_shape_file.centroid.y\n",
    "        ward_shape_file.rename(columns={'Ward_Name': 'ward'}, inplace=True)\n",
    "        ward_gps = ward_shape_file.sort_values('ward').groupby('ward').mean()[['approx_longitude', 'approx_latitude']]\n",
    "        ward_gps.reset_index(inplace=True)\n",
    "        ward_gps['ward'] = ward_gps['ward'].str.lower()\n",
    "\n",
    "        # Merging it with the main df\n",
    "        self.df = pd.merge(self.df, ward_gps, on='ward', how='left')\n",
    "        longitude_correls = self.df[['longitude', 'approx_longitude']].corr()\n",
    "        print(longitude_correls)\n",
    "        print(self.df[['latitude', 'approx_latitude']].corr())\n",
    "        print(f'Therefore a very accurate approximation as {round(pd.DataFrame(longitude_correls).iloc[0,1],2)} correlation \\n')\n",
    "\n",
    "        # Using the approximations to fill in the missing values\n",
    "        self.df.loc[pd.isnull(self.df['longitude']), 'longitude'] = self.df['approx_longitude']\n",
    "        self.df.loc[pd.isnull(self.df['latitude']), 'latitude'] = self.df['approx_latitude']\n",
    "        self.df.drop(columns=['approx_longitude', 'approx_latitude'], inplace=True)\n",
    "\n",
    "        # For the remaining 96 we will use the region/basin subgroup average as their entire ward is without GPS dta\n",
    "        self.df['longitude'] = self.df['longitude'].fillna(self.df.groupby(['region', 'basin'])['longitude'].transform('mean'))\n",
    "        self.df['latitude'] = self.df['latitude'].fillna(self.df.groupby(['region', 'basin'])['latitude'].transform('mean'))\n",
    "\n",
    "        # Then round to 8dp\n",
    "        self.df['longitude'] = self.df['longitude'].round(8)\n",
    "        self.df['latitude'] = self.df['latitude'].round(8)\n",
    "\n",
    "    def gps_height_imputation(self, training_data=True):\n",
    "        if training_data:\n",
    "            dataset='training'\n",
    "        else:\n",
    "            dataset = 'test'\n",
    "        altitudes = pd.read_csv(f'{dataset}_altitude_data.csv') # https://www.gpsvisualizer.com/convert_input?form=elevation\n",
    "        altitudes.drop_duplicates(inplace=True)\n",
    "        self.df = self.df.merge(altitudes, how='left', on=['longitude', 'latitude'])\n",
    "        self.df['gps_height'].fillna(self.df['altitude'], inplace=True)\n",
    "        self.df.drop(columns=['altitude'], inplace=True)\n",
    "\n",
    "    def mean_imputation(self, attribute: str, subgroups: list):\n",
    "        # Imputation - using subgroup imputation as no capacity for Tobit GLM regression in scikit\n",
    "        self.df[attribute] = self.df[attribute].fillna(self.df.groupby(subgroups)[attribute].transform('mean'))\n",
    "\n",
    "    def regression_imputation(self, attribute): # Pointon\n",
    "        params = self.df.columns.tolist()\n",
    "        params.remove(attribute)\n",
    "        temp_df = self.df.dropna()\n",
    "\n",
    "        # Estimate a Linear Regression model to estimate the missing data\n",
    "        imputation_model = linear_model.LinearRegression() # PoissonRegressor()\n",
    "        imputation_model.fit(X = temp_df[params], y = temp_df[attribute])\n",
    "\n",
    "        # Predict and add to df\n",
    "        temp_df2 = self.df[params].dropna()\n",
    "        imputation_values = pd.DataFrame(imputation_model.predict(temp_df2), index=temp_df2.index, columns=['imputation'])\n",
    "        self.df = self.df.join(imputation_values)\n",
    "        # self.df.sort_values(by='imputation') # sorts about half the values - need to override these!\n",
    "\n",
    "    def amount_tsh_imputation(self, training_data=True):\n",
    "        # Amount_tsh imputation\n",
    "        if training_data:\n",
    "            self.mean_imputation('amount_tsh', ['waterpoint_type_group', 'extraction_type_class', 'region', 'status_group'])\n",
    "        self.mean_imputation('amount_tsh', ['waterpoint_type_group', 'extraction_type_class', 'region'])\n",
    "        self.mean_imputation('amount_tsh', ['waterpoint_type_group', 'extraction_type_class'])\n",
    "        self.mean_imputation('amount_tsh', ['extraction_type_class']) # do we want waterpoint type or extraction type?\n",
    "        self.mean_imputation('amount_tsh', ['waterpoint_type_group'])\n",
    "\n",
    "    def construction_year_imputation(self, training_data=True):\n",
    "        # Construction year imputation\n",
    "        if training_data:\n",
    "            self.mean_imputation('construction_year', ['basin', 'region', 'lga', 'ward', 'subvillage'])\n",
    "            self.mean_imputation('construction_year', ['basin', 'region', 'lga', 'ward'])\n",
    "            self.mean_imputation('construction_year', ['basin', 'region', 'lga'])\n",
    "            self.mean_imputation('construction_year', ['basin', 'region'])\n",
    "            self.mean_imputation('construction_year', ['basin', 'waterpoint_type_group', 'extraction_type_class'])\n",
    "            self.mean_imputation('construction_year', ['basin', 'waterpoint_type_group'])\n",
    "            self.mean_imputation('construction_year', ['waterpoint_type_group'])\n",
    "        else:\n",
    "            for index, row in self.df.iterrows():\n",
    "                if pd.isna(row['construction_year']):\n",
    "                    value = self.training_data.loc[(self.training_data['basin']==row['basin']) & (self.training_data['region']==row['region']) & (self.training_data['lga']==row['lga']) & (self.training_data['ward']==row['ward']) & (self.training_data['subvillage']==row['subvillage'])]['construction_year'].mean()\n",
    "                    if pd.isna(value): # Therefore no imputation for that subgroup, so need to remove one filter\n",
    "                        value = self.training_data.loc[(self.training_data['basin']==row['basin']) & (self.training_data['region']==row['region']) & (self.training_data['lga']==row['lga']) & (self.training_data['ward']==row['ward'])]['construction_year'].mean()\n",
    "                        if pd.isna(value): # Therefore no imputation for that subgroup, so need to remove one filter\n",
    "                            value = self.training_data.loc[(self.training_data['basin']==row['basin']) & (self.training_data['region']==row['region']) & (self.training_data['lga']==row['lga'])]['construction_year'].mean()\n",
    "                            if pd.isna(value): # Therefore no imputation for that subgroup, so need to remove one filter\n",
    "                                value = self.training_data.loc[(self.training_data['basin']==row['basin']) & (self.training_data['region']==row['region'])]['construction_year'].mean()\n",
    "                                if pd.isna(value): # Therefore no imputation for that subgroup, so need to remove one filter\n",
    "                                    value = self.training_data.loc[(self.training_data['basin']==row['basin']) & (self.training_data['waterpoint_type_group']==row['waterpoint_type_group']) & (self.training_data['extraction_type_class']==row['extraction_type_class'])]['construction_year'].mean()\n",
    "                                    if pd.isna(value): # Therefore no imputation for that subgroup, so need to remove one filter\n",
    "                                        value = self.training_data.loc[(self.training_data['basin']==row['basin']) & (self.training_data['waterpoint_type_group']==row['waterpoint_type_group'])]['construction_year'].mean()\n",
    "                                        if pd.isna(value): # Therefore no imputation for that subgroup, so need to remove one filter\n",
    "                                            value = self.training_data.loc[(self.training_data['waterpoint_type_group']==row['waterpoint_type_group'])]['construction_year'].mean()\n",
    "                    self.df.loc[index, 'construction_year'] = value\n",
    "                else:\n",
    "                    pass\n",
    "        self.df['age'] = self.df['date_recorded'].dt.year-self.df['construction_year'] # create age col - keep as float due to no NaN representation for ints\n",
    "        self.df.loc[self.df['age']<0,'age'] = 0 # ensure a lower bound for age in case the imputations caused a negative age\n",
    "\n",
    "    def final_cleaning(self, pointon_analysis=False, training_data=True):\n",
    "        self.df.drop(columns=['date_recorded', 'population', 'construction_year'], inplace=True)\n",
    "        if pointon_analysis:\n",
    "            self.df.drop(columns=['subvillage', 'lga', 'ward'], inplace=True)\n",
    "        if training_data:\n",
    "            self.df.drop(columns=['status_group', 'NaNs'], inplace=True)\n",
    "\n",
    "    def cat_to_dummies(self, pointon_analysis=False):\n",
    "        if pointon_analysis: # Use smaller subgroups before converting to dummies to ensure model is parsimonious\n",
    "            # Group 'funder' into 3 categories (government, private, other)\n",
    "            self.df['funder'] = np.where((self.df['funder']=='government of tanzania') | (self.df['funder']=='district council'), 'government', self.df['funder'])\n",
    "            self.df['funder'] = np.where((self.df['funder']=='private') | (self.df['funder']=='government') | (self.df['funder']=='district council'), self.df['funder'], 'non-government')\n",
    "\n",
    "            # Group 'installer' into 3 categories (government, dwe, other)\n",
    "            self.df['installer'] = np.where(self.df['installer']=='district council', 'government', self.df['installer'])\n",
    "            self.df['installer'] = np.where((self.df['installer']=='dwe') | (self.df['installer']=='government') | (self.df['installer']=='district council'), self.df['installer'], 'other')\n",
    "\n",
    "        # Getting dummy vars from categorical data\n",
    "        self.DVs = []\n",
    "        for var in self.cat_cols:\n",
    "            dummies = pd.get_dummies(self.df[var]).add_prefix(var+\": \").iloc[:,1:] # first last dummy to avoid DV trap\n",
    "            self.df = pd.concat([self.df, dummies], axis=1)\n",
    "            self.df.drop(columns=[var], inplace=True)\n",
    "            self.DVs += list(dummies)\n",
    "\n",
    "    def normalise(self, c):\n",
    "        self.df[c] = (self.df[c] - self.df[c].min())/(self.df[c].max()-self.df[c].min())\n",
    "\n",
    "    def standardise(self, c):\n",
    "        self.df[c] = (self.df[c] - self.df[c].mean())/(self.df[c].std())\n",
    "\n",
    "    def normalise_standardise(self, normalise_cols, standardise_cols):\n",
    "        # Standardising prior to PCA - mostly standardising because of outliers/large values relative to the data skew\n",
    "        for col in normalise_cols:\n",
    "            self.normalise(col)\n",
    "\n",
    "        for col in standardise_cols:\n",
    "            self.standardise(col)\n",
    "\n",
    "    def normalise_long_lat(self):\n",
    "        centre_lat = -6.3728\n",
    "        centre_long = 34.8925\n",
    "\n",
    "        self.df['latitude'] = self.df['latitude'] - centre_lat\n",
    "        self.df['longitude'] = self.df['longitude'] - centre_long\n",
    "\n",
    "    def find_missing_values(self):\n",
    "        # Missing data\n",
    "        df_missing = self.df[self.df.columns[self.df.isnull().any()]]\n",
    "\n",
    "        # Number of NaNs per col:\n",
    "        print(f'The number of missing values per column is:\\n {df_missing.isna().sum()}')\n",
    "\n",
    "        # Visual missing data analysis\n",
    "        if df_missing.empty:\n",
    "            return\n",
    "        else:\n",
    "            return msno.matrix(df_missing) # as can be seen, missing values are attribute-dependent and not record-dependent\n",
    "\n",
    "    # def final_cleaning(self):\n",
    "    #     self.df.drop(columns=['subvillage'], inplace=True)\n",
    "\n",
    "    def get_geo_graphic(self): # Pointon and Braganza\n",
    "        # JB adapting the df to make it a geo-df with coordinate mapping\n",
    "        crs = {'init': 'epsg:4326'} # Coordinate Reference System\n",
    "        geometry = [Point(xy) for xy in zip(self.df['longitude'], self.df['latitude'])] # creating the geometry mapping from log/lat data\n",
    "        geo_df = gpd.GeoDataFrame(self.df, crs =crs, geometry = geometry)\n",
    "\n",
    "        # JP getting ready to plot the % functional pumps by region\n",
    "        districtMap = gpd.read_file('ShapeMaps/gadm41_TZA_1.shp') # from https://gadm.org/download_country.html\n",
    "        districtMap.rename(columns={'NAME_1':'region'}, inplace=True)\n",
    "        for column in districtMap.columns:\n",
    "            if districtMap[column].dtype==object: # and col not in ['public_meeting']\n",
    "                districtMap[column] = districtMap[column].str.lower()\n",
    "\n",
    "        # Adapting the shapemap to fit the data's regional splits\n",
    "        districtMap.loc[districtMap['region']=='katavi', 'region'] = 'rukwa'\n",
    "        districtMap.loc[(districtMap['region']=='geita') | (districtMap['region']=='simiyu'), 'region'] = 'shinyanga'\n",
    "        # geita -> shinyanga is an approximation!\n",
    "        districtMap.loc[districtMap['region']=='njombe', 'region'] = 'iringa'\n",
    "        districtMap.loc[districtMap['region']=='songwe', 'region'] = 'mbeya'\n",
    "\n",
    "        # Calculating number of functional pumps per region\n",
    "        num_pumps = self.df.groupby('region').count()['status_group']\n",
    "        num_functional_pumps = self.df.loc[self.df['status_group'] == 'functional'].groupby('region').count()['status_group']\n",
    "        # num_functional_pumps = num_functional_pumps.reset_index()\n",
    "        perc_functional_regional = pd.concat([num_pumps, num_functional_pumps], axis=1)\n",
    "        # perc_functional_regional = num_functional_pumps.join(num_pumps, on=['region'])\n",
    "        perc_functional_regional.columns = ['Total', 'Functional']\n",
    "        perc_functional_regional['proportion'] = perc_functional_regional['Functional']/perc_functional_regional['Total']\n",
    "\n",
    "        # Merging num_pumps with the shapemap\n",
    "        perc_functional_regional = districtMap.join(perc_functional_regional, on=['region'])\n",
    "\n",
    "        # Creating the graphic\n",
    "        ax = perc_functional_regional.plot(column='proportion', legend=True, legend_kwds={'label': \"Proportion of working water pumps\"})\n",
    "        geo_df.loc[geo_df['population']>10000].dropna(subset=['longitude', 'latitude']).plot(ax = ax, markersize = 0.008, color = \"blue\", marker = \"o\", label = \"Pump\")\n",
    "        plt.legend(prop={'size': 10})\n",
    "        plt.title('Geographical distribution of water pumps')\n",
    "        plt.xlabel('Longitude')\n",
    "        plt.ylabel('Latitude')\n",
    "        plt.savefig('Output/pumps_and_regional_functionality.png', dpi=1200)\n",
    "\n",
    "    def drop_insig_cols(self):\n",
    "        self.df.drop(columns=['waterpoint_type_group', 'basin: lake tanganyika', 'basin: pangani', 'basin: rufiji', 'basin: ruvuma / southern coast', 'basin: wami / ruvu', 'basin: lake nyasa', 'basin: lake rukwa', 'gps_height', 'region: mara', 'region: mbeya', 'region: mwanza', 'region: manyara', 'region: mtwara', 'region: pwani', 'region: lindi', 'permit: true', 'permit: unknown', 'source: hand dtw', 'water_quality: salty abandoned', 'water_quality: soft', 'amount_tsh', 'longitude', 'latitude'], inplace=True) # REMOVING AMOUNT_TSH HERE\n",
    "        # self.df.loc[self.df['amount_tsh']>0, 'amount_tsh']=1 # make it binary\n",
    "\n",
    "class Training(Dataset):\n",
    "    def __init__(self, data):\n",
    "        super().__init__(data)\n",
    "\n",
    "    def get_x_y_split(self):\n",
    "        y = self.df['status_group_encoding']\n",
    "        x = self.df.loc[:, self.df.columns!='status_group_encoding']\n",
    "        return y, x\n",
    "\n",
    "    def initial_preprocessing(self):\n",
    "        self.initial_cleaning() # Clean data\n",
    "\n",
    "        # GPS Imputation\n",
    "        self.long_lat_imputation() # Using the external shapefile\n",
    "        self.df.loc[pd.isnull(self.df['gps_height'])].to_csv('longlat_training.csv')\n",
    "        self.gps_height_imputation() # Using the external source from the longlat values\n",
    "\n",
    "        # Other imputations\n",
    "        self.amount_tsh_imputation() # Mean imputation by subgroup\n",
    "        self.construction_year_imputation() # Mean imputation by subgroup\n",
    "\n",
    "    def final_preprocessing(self, pointon_analysis=False):\n",
    "        self.final_cleaning(pointon_analysis=pointon_analysis) # Drop some cols\n",
    "\n",
    "        self.find_missing_values() # Can be commented out\n",
    "        self.cat_to_dummies(pointon_analysis=pointon_analysis) # Convert categorical columns to dummies\n",
    "        self.normalise_standardise([], ['amount_tsh', 'gps_height', 'age']) # Normalisation/standardisation\n",
    "        self.normalise_long_lat() # Normalising 'longitude' and 'latitude' using a central point so they are within [-5,5]\n",
    "\n",
    "        if pointon_analysis:\n",
    "            self.drop_insig_cols()\n",
    "\n",
    "class Test(Dataset):\n",
    "    def __init__(self, data, training_data):\n",
    "        super().__init__(data, training_data)\n",
    "\n",
    "    def preprocessing(self, pointon_analysis=False):\n",
    "        self.initial_cleaning(training_data=False) # Clean data but ignore the amount_tsh fix because we haven't got the status_group to verify\n",
    "\n",
    "        # GPS Imputation\n",
    "        self.long_lat_imputation() # Using the external shapefile\n",
    "        self.df.loc[pd.isnull(self.df['gps_height'])].to_csv('longlat_test.csv')\n",
    "        self.gps_height_imputation(training_data=False) # Using the external source from the longlat values\n",
    "\n",
    "        # Other imputations\n",
    "        self.amount_tsh_imputation(training_data=False) # Mean imputation by subgroup\n",
    "        self.construction_year_imputation(training_data=False) # Mean imputation by subgroup\n",
    "        self.final_cleaning(pointon_analysis=pointon_analysis, training_data=False) # Drop some cols\n",
    "\n",
    "        self.find_missing_values() # Can be commented out\n",
    "        self.cat_to_dummies(pointon_analysis=pointon_analysis) # Convert categorical columns to dummies\n",
    "        self.normalise_standardise([], ['amount_tsh', 'gps_height', 'age']) # Normalisation/standardisation\n",
    "        self.normalise_long_lat() # Normalising 'longitude' and 'latitude' using a central point so they are within [-5,5]\n",
    "\n",
    "        if pointon_analysis:\n",
    "            self.drop_insig_cols()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Training' object has no attribute 'convert_missing_to_unkown'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[8], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m training \u001b[39m=\u001b[39m Training(training_df) \u001b[39m# Create Dataset instance for training data\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m training\u001b[39m.\u001b[39;49minitial_preprocessing() \u001b[39m# Pause after this to take a snapshot for the test data imputations\u001b[39;00m\n\u001b[1;32m      3\u001b[0m training_df_for_test_imputations \u001b[39m=\u001b[39m copy\u001b[39m.\u001b[39mdeepcopy(training\u001b[39m.\u001b[39mdf) \u001b[39m# Take a copy of the df\u001b[39;00m\n\u001b[1;32m      4\u001b[0m training\u001b[39m.\u001b[39mfinal_preprocessing(pointon_analysis\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m) \u001b[39m# Continue with the preprocessing\u001b[39;00m\n",
      "Cell \u001b[0;32mIn[7], line 329\u001b[0m, in \u001b[0;36mTraining.initial_preprocessing\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    328\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39minitial_preprocessing\u001b[39m(\u001b[39mself\u001b[39m):\n\u001b[0;32m--> 329\u001b[0m     \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49minitial_cleaning() \u001b[39m# Clean data\u001b[39;00m\n\u001b[1;32m    331\u001b[0m     \u001b[39m# GPS Imputation\u001b[39;00m\n\u001b[1;32m    332\u001b[0m     \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mlong_lat_imputation() \u001b[39m# Using the external shapefile\u001b[39;00m\n",
      "Cell \u001b[0;32mIn[7], line 100\u001b[0m, in \u001b[0;36mDataset.initial_cleaning\u001b[0;34m(self, training_data)\u001b[0m\n\u001b[1;32m     98\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mconvert_datetime()\n\u001b[1;32m     99\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mconvert_missing_values(training_data\u001b[39m=\u001b[39mtraining_data)\n\u001b[0;32m--> 100\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mconvert_missing_to_unkown()\n\u001b[1;32m    101\u001b[0m \u001b[39m# self.create_new_attributes()\u001b[39;00m\n\u001b[1;32m    102\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mconvert_lowercase()\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'Training' object has no attribute 'convert_missing_to_unkown'"
     ]
    }
   ],
   "source": [
    "training = Training(training_df) # Create Dataset instance for training data\n",
    "training.initial_preprocessing() # Pause after this to take a snapshot for the test data imputations\n",
    "training_df_for_test_imputations = copy.deepcopy(training.df) # Take a copy of the df\n",
    "training.final_preprocessing(pointon_analysis=True) # Continue with the preprocessing\n",
    "training.df = training.df.dropna() # REMOVE THE DROPNA\n",
    "y_train, X_train = training.get_x_y_split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\point\\AppData\\Local\\Temp\\ipykernel_19280\\721031402.py:112: UserWarning: Geometry is in a geographic CRS. Results from 'centroid' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n",
      "\n",
      "  ward_shape_file['approx_longitude'] = ward_shape_file.centroid.x\n",
      "C:\\Users\\point\\AppData\\Local\\Temp\\ipykernel_19280\\721031402.py:113: UserWarning: Geometry is in a geographic CRS. Results from 'centroid' are likely incorrect. Use 'GeoSeries.to_crs()' to re-project geometries to a projected CRS before this operation.\n",
      "\n",
      "  ward_shape_file['approx_latitude'] = ward_shape_file.centroid.y\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                  longitude  approx_longitude\n",
      "longitude          1.000000          0.979731\n",
      "approx_longitude   0.979731          1.000000\n",
      "                 latitude  approx_latitude\n",
      "latitude         1.000000         0.983669\n",
      "approx_latitude  0.983669         1.000000\n",
      "Therefore a very accurate approximation as 0.98 correlation \n",
      "\n",
      "The number of missing values per column is:\n",
      " Series([], dtype: float64)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>age</th>\n",
       "      <th>funder: non-government</th>\n",
       "      <th>installer: government</th>\n",
       "      <th>installer: other</th>\n",
       "      <th>basin: lake victoria</th>\n",
       "      <th>region: dar es salaam</th>\n",
       "      <th>region: dodoma</th>\n",
       "      <th>region: iringa</th>\n",
       "      <th>region: kagera</th>\n",
       "      <th>region: kigoma</th>\n",
       "      <th>...</th>\n",
       "      <th>quantity: seasonal</th>\n",
       "      <th>quantity: unknown</th>\n",
       "      <th>source: lake</th>\n",
       "      <th>source: machine dbh</th>\n",
       "      <th>source: other</th>\n",
       "      <th>source: rainwater harvesting</th>\n",
       "      <th>source: river</th>\n",
       "      <th>source: shallow well</th>\n",
       "      <th>source: spring</th>\n",
       "      <th>source: unknown</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-1.357414</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>-0.182166</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>-1.161539</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.091020</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>-0.182166</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14845</th>\n",
       "      <td>0.797208</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14846</th>\n",
       "      <td>0.209584</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14847</th>\n",
       "      <td>-1.161539</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14848</th>\n",
       "      <td>-1.063602</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14849</th>\n",
       "      <td>-0.965664</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>...</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>14850 rows × 51 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "            age  funder: non-government  installer: government  \\\n",
       "0     -1.357414                       1                      0   \n",
       "1     -0.182166                       0                      0   \n",
       "2     -1.161539                       1                      0   \n",
       "3      1.091020                       1                      0   \n",
       "4     -0.182166                       1                      0   \n",
       "...         ...                     ...                    ...   \n",
       "14845  0.797208                       1                      0   \n",
       "14846  0.209584                       1                      0   \n",
       "14847 -1.161539                       1                      0   \n",
       "14848 -1.063602                       1                      0   \n",
       "14849 -0.965664                       0                      1   \n",
       "\n",
       "       installer: other  basin: lake victoria  region: dar es salaam  \\\n",
       "0                     1                     0                      0   \n",
       "1                     0                     0                      0   \n",
       "2                     1                     0                      0   \n",
       "3                     1                     0                      0   \n",
       "4                     1                     0                      0   \n",
       "...                 ...                   ...                    ...   \n",
       "14845                 1                     0                      0   \n",
       "14846                 1                     0                      0   \n",
       "14847                 1                     0                      0   \n",
       "14848                 0                     0                      0   \n",
       "14849                 0                     0                      0   \n",
       "\n",
       "       region: dodoma  region: iringa  region: kagera  region: kigoma  ...  \\\n",
       "0                   0               0               0               0  ...   \n",
       "1                   0               0               0               0  ...   \n",
       "2                   0               0               0               0  ...   \n",
       "3                   0               0               0               0  ...   \n",
       "4                   0               0               0               0  ...   \n",
       "...               ...             ...             ...             ...  ...   \n",
       "14845               0               0               0               0  ...   \n",
       "14846               0               0               0               0  ...   \n",
       "14847               0               0               0               0  ...   \n",
       "14848               0               0               0               0  ...   \n",
       "14849               0               0               0               0  ...   \n",
       "\n",
       "       quantity: seasonal  quantity: unknown  source: lake  \\\n",
       "0                       1                  0             0   \n",
       "1                       0                  0             0   \n",
       "2                       0                  0             0   \n",
       "3                       0                  0             0   \n",
       "4                       0                  0             0   \n",
       "...                   ...                ...           ...   \n",
       "14845                   0                  0             0   \n",
       "14846                   0                  0             0   \n",
       "14847                   0                  0             0   \n",
       "14848                   0                  0             0   \n",
       "14849                   0                  0             0   \n",
       "\n",
       "       source: machine dbh  source: other  source: rainwater harvesting  \\\n",
       "0                        0              0                             1   \n",
       "1                        0              0                             0   \n",
       "2                        0              0                             1   \n",
       "3                        0              0                             0   \n",
       "4                        0              0                             0   \n",
       "...                    ...            ...                           ...   \n",
       "14845                    0              0                             0   \n",
       "14846                    0              0                             0   \n",
       "14847                    0              0                             0   \n",
       "14848                    0              0                             0   \n",
       "14849                    0              0                             0   \n",
       "\n",
       "       source: river  source: shallow well  source: spring  source: unknown  \n",
       "0                  0                     0               0                0  \n",
       "1                  0                     0               1                0  \n",
       "2                  0                     0               0                0  \n",
       "3                  0                     1               0                0  \n",
       "4                  0                     0               1                0  \n",
       "...              ...                   ...             ...              ...  \n",
       "14845              1                     0               0                0  \n",
       "14846              0                     1               0                0  \n",
       "14847              0                     0               0                0  \n",
       "14848              1                     0               0                0  \n",
       "14849              0                     0               1                0  \n",
       "\n",
       "[14850 rows x 51 columns]"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test = Test(test_df, training_df_for_test_imputations) # Create Dataset instance for test data - IMPORTANT TO CREATE THIS AFTER CLEANING THE TRAINING DATASET as the mean imputation relies on the cleaned dataset\n",
    "test.preprocessing(pointon_analysis=True)\n",
    "test.df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>status_group</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>50785</td>\n",
       "      <td>functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>51630</td>\n",
       "      <td>functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>17168</td>\n",
       "      <td>functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>45559</td>\n",
       "      <td>non functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>49871</td>\n",
       "      <td>functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14845</th>\n",
       "      <td>39307</td>\n",
       "      <td>non functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14846</th>\n",
       "      <td>18990</td>\n",
       "      <td>functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14847</th>\n",
       "      <td>28749</td>\n",
       "      <td>functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14848</th>\n",
       "      <td>33492</td>\n",
       "      <td>functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14849</th>\n",
       "      <td>68707</td>\n",
       "      <td>non functional</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>14850 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "          id    status_group\n",
       "0      50785      functional\n",
       "1      51630      functional\n",
       "2      17168      functional\n",
       "3      45559  non functional\n",
       "4      49871      functional\n",
       "...      ...             ...\n",
       "14845  39307  non functional\n",
       "14846  18990      functional\n",
       "14847  28749      functional\n",
       "14848  33492      functional\n",
       "14849  68707  non functional\n",
       "\n",
       "[14850 rows x 2 columns]"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# training.df['extraction_type_class'].value_counts()\n",
    "from sklearn import datasets\n",
    "from sklearn import metrics\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.neural_network import MLPRegressor\n",
    "\n",
    "# training.df.drop(columns=['status_group'], inplace=True)\n",
    "\n",
    "model = MLPClassifier(hidden_layer_sizes=(100,), max_iter=500, alpha=0.5) # Don't want to be too simple but don't want to overfit - (93inputs + 3outputs)*2/3 as per https://medium.com/geekculture/introduction-to-neural-network-2f8b8221fbd3\n",
    "# (64,64) accuracy: 0.5622\n",
    "# (64,) accuracy: 0.5426\n",
    "model.fit(X_train, y_train)\n",
    "predicted_y = model.predict(test.df)\n",
    "\n",
    "def decode_dep_var(model_predictions):\n",
    "    # Do we want to do these?\n",
    "    model_predictions = pd.DataFrame(model_predictions)\n",
    "    model_predictions['status_group'] = model_predictions[0].replace(0, \"non functional\")\n",
    "    model_predictions['status_group'].replace(1, \"functional needs repair\", inplace=True)\n",
    "    model_predictions['status_group'].replace(2, \"functional\", inplace=True)\n",
    "    model_predictions.drop(columns=[0], inplace=True)\n",
    "    return model_predictions\n",
    "\n",
    "def concat_id_and_predictions(test_object, predictions):\n",
    "    prediction_output = pd.DataFrame()\n",
    "    prediction_output['id'] = test_object.ids\n",
    "    prediction_output['status_group'] = predictions\n",
    "    return prediction_output\n",
    "\n",
    "predicted_y = decode_dep_var(predicted_y)\n",
    "prediction_output = concat_id_and_predictions(test, predicted_y)\n",
    "prediction_output.to_csv('pointon_predictions_MLP_alpha0_5.csv', index=False)\n",
    "prediction_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 432x288 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "plt.matshow(cm)\n",
    "plt.savefig('Output/confusion_matrix.png', dpi=1200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Optimization terminated successfully.\n",
      "         Current function value: 0.666018\n",
      "         Iterations: 500\n",
      "         Function evaluations: 501\n",
      "         Gradient evaluations: 501\n",
      "                            MNLogit Regression Results                           \n",
      "=================================================================================\n",
      "Dep. Variable:     status_group_encoding   No. Observations:                59087\n",
      "Model:                           MNLogit   Df Residuals:                    58983\n",
      "Method:                              MLE   Df Model:                          102\n",
      "Date:                   Thu, 23 Mar 2023   Pseudo R-squ.:                  0.2512\n",
      "Time:                           10:51:47   Log-Likelihood:                -39353.\n",
      "converged:                          True   LL-Null:                       -52553.\n",
      "Covariance Type:               nonrobust   LLR p-value:                     0.000\n",
      "=======================================================================================================\n",
      "            status_group_encoding=1       coef    std err          z      P>|z|      [0.025      0.975]\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "const                                  -6.4988      0.285    -22.798      0.000      -7.058      -5.940\n",
      "age                                    -0.1202      0.020     -5.956      0.000      -0.160      -0.081\n",
      "funder: non-government                  0.4888      0.060      8.186      0.000       0.372       0.606\n",
      "installer: government                  -0.1934      0.079     -2.453      0.014      -0.348      -0.039\n",
      "installer: other                       -0.4194      0.043     -9.776      0.000      -0.503      -0.335\n",
      "basin: lake victoria                    0.8126      0.065     12.540      0.000       0.686       0.940\n",
      "region: dar es salaam                  -1.7763      0.596     -2.981      0.003      -2.944      -0.608\n",
      "region: dodoma                          1.1460      0.100     11.412      0.000       0.949       1.343\n",
      "region: iringa                         -0.8462      0.112     -7.589      0.000      -1.065      -0.628\n",
      "region: kagera                         -0.5592      0.090     -6.199      0.000      -0.736      -0.382\n",
      "region: kigoma                          0.8678      0.076     11.368      0.000       0.718       1.017\n",
      "region: kilimanjaro                    -0.3933      0.079     -4.964      0.000      -0.549      -0.238\n",
      "region: morogoro                        0.0867      0.080      1.077      0.282      -0.071       0.244\n",
      "region: rukwa                           0.0278      0.112      0.247      0.805      -0.192       0.248\n",
      "region: ruvuma                          0.2768      0.105      2.629      0.009       0.070       0.483\n",
      "region: shinyanga                       1.5460      0.074     20.806      0.000       1.400       1.692\n",
      "region: singida                         1.1769      0.116     10.127      0.000       0.949       1.405\n",
      "region: tabora                         -0.2121      0.163     -1.299      0.194      -0.532       0.108\n",
      "region: tanga                          -0.8699      0.133     -6.541      0.000      -1.131      -0.609\n",
      "extraction_type_class: handpump        -0.5498      0.106     -5.168      0.000      -0.758      -0.341\n",
      "extraction_type_class: motorpump       -0.9322      0.132     -7.077      0.000      -1.190      -0.674\n",
      "extraction_type_class: other           -1.9636      0.107    -18.415      0.000      -2.173      -1.755\n",
      "extraction_type_class: rope pump       -0.7469      0.281     -2.659      0.008      -1.297      -0.196\n",
      "extraction_type_class: submersible     -0.5962      0.102     -5.864      0.000      -0.795      -0.397\n",
      "extraction_type_class: wind-powered    -1.0797      0.422     -2.558      0.011      -1.907      -0.252\n",
      "management_group: other                 0.8303      0.194      4.276      0.000       0.450       1.211\n",
      "management_group: parastatal            0.7186      0.146      4.910      0.000       0.432       1.005\n",
      "management_group: unknown               1.1576      0.252      4.587      0.000       0.663       1.652\n",
      "management_group: user-group            0.7049      0.105      6.684      0.000       0.498       0.912\n",
      "payment_type: monthly                   0.0123      0.095      0.130      0.897      -0.174       0.199\n",
      "payment_type: never pay                -0.7156      0.091     -7.879      0.000      -0.894      -0.538\n",
      "payment_type: on failure               -0.3136      0.111     -2.836      0.005      -0.530      -0.097\n",
      "payment_type: other                    -0.7540      0.154     -4.889      0.000      -1.056      -0.452\n",
      "payment_type: per bucket               -0.3984      0.109     -3.660      0.000      -0.612      -0.185\n",
      "payment_type: unknown                  -1.4263      0.105    -13.590      0.000      -1.632      -1.221\n",
      "water_quality: fluoride                 0.5743      0.334      1.718      0.086      -0.081       1.229\n",
      "water_quality: fluoride abandoned      -1.1385      1.385     -0.822      0.411      -3.853       1.576\n",
      "water_quality: milky                   -0.6188      0.285     -2.172      0.030      -1.177      -0.060\n",
      "water_quality: salty                    0.0578      0.081      0.714      0.475      -0.101       0.216\n",
      "water_quality: unknown                 -0.2416      0.216     -1.117      0.264      -0.666       0.182\n",
      "quantity: enough                        3.7858      0.169     22.390      0.000       3.454       4.117\n",
      "quantity: insufficient                  3.7992      0.170     22.295      0.000       3.465       4.133\n",
      "quantity: seasonal                      3.6429      0.180     20.222      0.000       3.290       3.996\n",
      "quantity: unknown                       1.8382      0.368      4.996      0.000       1.117       2.559\n",
      "source: lake                           -1.1022      0.344     -3.209      0.001      -1.776      -0.429\n",
      "source: machine dbh                     0.8812      0.180      4.894      0.000       0.528       1.234\n",
      "source: other                          -0.5576      1.120     -0.498      0.619      -2.752       1.637\n",
      "source: rainwater harvesting            2.2497      0.197     11.426      0.000       1.864       2.636\n",
      "source: river                           1.7385      0.181      9.617      0.000       1.384       2.093\n",
      "source: shallow well                    0.8955      0.182      4.934      0.000       0.540       1.251\n",
      "source: spring                          1.6967      0.181      9.381      0.000       1.342       2.051\n",
      "source: unknown                         1.5434      0.567      2.720      0.007       0.431       2.655\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "            status_group_encoding=2       coef    std err          z      P>|z|      [0.025      0.975]\n",
      "-------------------------------------------------------------------------------------------------------\n",
      "const                                  -4.2455      0.142    -29.910      0.000      -4.524      -3.967\n",
      "age                                    -0.3852      0.012    -32.361      0.000      -0.409      -0.362\n",
      "funder: non-government                  0.3913      0.035     11.027      0.000       0.322       0.461\n",
      "installer: government                  -0.5820      0.052    -11.246      0.000      -0.683      -0.481\n",
      "installer: other                       -0.1014      0.027     -3.793      0.000      -0.154      -0.049\n",
      "basin: lake victoria                    0.2076      0.039      5.356      0.000       0.132       0.284\n",
      "region: dar es salaam                   0.2301      0.100      2.312      0.021       0.035       0.425\n",
      "region: dodoma                          0.5404      0.068      7.981      0.000       0.408       0.673\n",
      "region: iringa                          0.6725      0.054     12.415      0.000       0.566       0.779\n",
      "region: kagera                         -0.2961      0.055     -5.367      0.000      -0.404      -0.188\n",
      "region: kigoma                         -0.2369      0.055     -4.284      0.000      -0.345      -0.129\n",
      "region: kilimanjaro                    -0.3384      0.047     -7.139      0.000      -0.431      -0.245\n",
      "region: morogoro                        0.0280      0.047      0.597      0.551      -0.064       0.120\n",
      "region: rukwa                          -0.3495      0.068     -5.150      0.000      -0.483      -0.216\n",
      "region: ruvuma                          0.4351      0.065      6.714      0.000       0.308       0.562\n",
      "region: shinyanga                       0.5837      0.049     11.949      0.000       0.488       0.679\n",
      "region: singida                         0.6946      0.069     10.076      0.000       0.560       0.830\n",
      "region: tabora                          0.0966      0.062      1.550      0.121      -0.026       0.219\n",
      "region: tanga                           0.2128      0.056      3.798      0.000       0.103       0.323\n",
      "extraction_type_class: handpump         0.6775      0.056     12.018      0.000       0.567       0.788\n",
      "extraction_type_class: motorpump       -0.4767      0.070     -6.853      0.000      -0.613      -0.340\n",
      "extraction_type_class: other           -1.6051      0.058    -27.580      0.000      -1.719      -1.491\n",
      "extraction_type_class: rope pump        0.2351      0.128      1.838      0.066      -0.016       0.486\n",
      "extraction_type_class: submersible     -0.3187      0.054     -5.927      0.000      -0.424      -0.213\n",
      "extraction_type_class: wind-powered    -0.3832      0.230     -1.665      0.096      -0.834       0.068\n",
      "management_group: other                 0.5507      0.105      5.247      0.000       0.345       0.756\n",
      "management_group: parastatal           -0.1498      0.081     -1.857      0.063      -0.308       0.008\n",
      "management_group: unknown               0.3080      0.129      2.379      0.017       0.054       0.562\n",
      "management_group: user-group           -0.1326      0.046     -2.864      0.004      -0.223      -0.042\n",
      "payment_type: monthly                  -0.2344      0.063     -3.722      0.000      -0.358      -0.111\n",
      "payment_type: never pay                -1.0734      0.058    -18.450      0.000      -1.187      -0.959\n",
      "payment_type: on failure               -0.4576      0.069     -6.640      0.000      -0.593      -0.323\n",
      "payment_type: other                    -0.7704      0.104     -7.417      0.000      -0.974      -0.567\n",
      "payment_type: per bucket                0.0585      0.066      0.885      0.376      -0.071       0.188\n",
      "payment_type: unknown                  -1.1373      0.065    -17.450      0.000      -1.265      -1.010\n",
      "water_quality: fluoride                 1.0366      0.201      5.148      0.000       0.642       1.431\n",
      "water_quality: fluoride abandoned      -1.0281      0.580     -1.774      0.076      -2.164       0.108\n",
      "water_quality: milky                    0.9431      0.101      9.310      0.000       0.745       1.142\n",
      "water_quality: salty                   -0.1745      0.041     -4.279      0.000      -0.254      -0.095\n",
      "water_quality: unknown                 -0.5635      0.113     -4.997      0.000      -0.784      -0.342\n",
      "quantity: enough                        4.5927      0.086     53.679      0.000       4.425       4.760\n",
      "quantity: insufficient                  4.1909      0.087     48.167      0.000       4.020       4.361\n",
      "quantity: seasonal                      4.1857      0.094     44.653      0.000       4.002       4.369\n",
      "quantity: unknown                       3.4339      0.146     23.473      0.000       3.147       3.721\n",
      "source: lake                           -0.2819      0.128     -2.200      0.028      -0.533      -0.031\n",
      "source: machine dbh                     0.4908      0.072      6.844      0.000       0.350       0.631\n",
      "source: other                           1.8985      0.200      9.505      0.000       1.507       2.290\n",
      "source: rainwater harvesting            2.0388      0.096     21.247      0.000       1.851       2.227\n",
      "source: river                           1.2057      0.078     15.377      0.000       1.052       1.359\n",
      "source: shallow well                    0.4881      0.072      6.760      0.000       0.347       0.630\n",
      "source: spring                          1.6180      0.079     20.542      0.000       1.464       1.772\n",
      "source: unknown                         1.3539      0.313      4.331      0.000       0.741       1.967\n",
      "=======================================================================================================\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "Classification metrics can't handle a mix of multiclass and continuous-multioutput targets",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[1;32mIn [237]\u001b[0m, in \u001b[0;36m<cell line: 17>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     14\u001b[0m training_prediction \u001b[38;5;241m=\u001b[39m model\u001b[38;5;241m.\u001b[39mpredict(sm\u001b[38;5;241m.\u001b[39madd_constant(X_train))\u001b[38;5;66;03m#.idxmax(axis=1)\u001b[39;00m\n\u001b[0;32m     15\u001b[0m \u001b[38;5;66;03m# prediction = list(map(round, yhat))\u001b[39;00m\n\u001b[0;32m     16\u001b[0m \u001b[38;5;66;03m# confusion matrix\u001b[39;00m\n\u001b[1;32m---> 17\u001b[0m cm \u001b[38;5;241m=\u001b[39m \u001b[43mconfusion_matrix\u001b[49m\u001b[43m(\u001b[49m\u001b[43my_train\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtraining_prediction\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     18\u001b[0m \u001b[38;5;28mprint\u001b[39m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mConfusion Matrix : \u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, cm)\n\u001b[0;32m     20\u001b[0m \u001b[38;5;66;03m# accuracy score of the model\u001b[39;00m\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\sklearn\\metrics\\_classification.py:307\u001b[0m, in \u001b[0;36mconfusion_matrix\u001b[1;34m(y_true, y_pred, labels, sample_weight, normalize)\u001b[0m\n\u001b[0;32m    222\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mconfusion_matrix\u001b[39m(\n\u001b[0;32m    223\u001b[0m     y_true, y_pred, \u001b[38;5;241m*\u001b[39m, labels\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, sample_weight\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, normalize\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m    224\u001b[0m ):\n\u001b[0;32m    225\u001b[0m     \u001b[38;5;124;03m\"\"\"Compute confusion matrix to evaluate the accuracy of a classification.\u001b[39;00m\n\u001b[0;32m    226\u001b[0m \n\u001b[0;32m    227\u001b[0m \u001b[38;5;124;03m    By definition a confusion matrix :math:`C` is such that :math:`C_{i, j}`\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    305\u001b[0m \u001b[38;5;124;03m    (0, 2, 1, 1)\u001b[39;00m\n\u001b[0;32m    306\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[1;32m--> 307\u001b[0m     y_type, y_true, y_pred \u001b[38;5;241m=\u001b[39m \u001b[43m_check_targets\u001b[49m\u001b[43m(\u001b[49m\u001b[43my_true\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_pred\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    308\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m y_type \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m (\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbinary\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmulticlass\u001b[39m\u001b[38;5;124m\"\u001b[39m):\n\u001b[0;32m    309\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m is not supported\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m y_type)\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\sklearn\\metrics\\_classification.py:93\u001b[0m, in \u001b[0;36m_check_targets\u001b[1;34m(y_true, y_pred)\u001b[0m\n\u001b[0;32m     90\u001b[0m     y_type \u001b[38;5;241m=\u001b[39m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmulticlass\u001b[39m\u001b[38;5;124m\"\u001b[39m}\n\u001b[0;32m     92\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(y_type) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m---> 93\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[0;32m     94\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mClassification metrics can\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt handle a mix of \u001b[39m\u001b[38;5;132;01m{0}\u001b[39;00m\u001b[38;5;124m and \u001b[39m\u001b[38;5;132;01m{1}\u001b[39;00m\u001b[38;5;124m targets\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(\n\u001b[0;32m     95\u001b[0m             type_true, type_pred\n\u001b[0;32m     96\u001b[0m         )\n\u001b[0;32m     97\u001b[0m     )\n\u001b[0;32m     99\u001b[0m \u001b[38;5;66;03m# We can't have more than one value on y_type => The set is no more needed\u001b[39;00m\n\u001b[0;32m    100\u001b[0m y_type \u001b[38;5;241m=\u001b[39m y_type\u001b[38;5;241m.\u001b[39mpop()\n",
      "\u001b[1;31mValueError\u001b[0m: Classification metrics can't handle a mix of multiclass and continuous-multioutput targets"
     ]
    }
   ],
   "source": [
    "import statsmodels.api as sm\n",
    "from sklearn.metrics import (confusion_matrix, accuracy_score)\n",
    "model = sm.MNLogit(y_train,sm.add_constant(X_train)).fit(method='bfgs', maxiter=2000) #.fit_regularized(method='l1', maxiter=2000, alpha=5.1)\n",
    "# model = sm.MNLogit(y_train, sm.add_constant(X_train)).fit(maxiter=1000)\n",
    "print(model.summary())\n",
    "training_prediction = model.predict(sm.add_constant(X_train)).idxmax(axis=1)\n",
    "# prediction = list(map(round, yhat))\n",
    "# confusion matrix\n",
    "cm = confusion_matrix(y_train, training_prediction)\n",
    "print (\"Confusion Matrix : \\n\", cm)\n",
    "\n",
    "# accuracy score of the model\n",
    "print('Training accuracy = ', accuracy_score(y_train, training_prediction))\n",
    "\n",
    "# prediction = model.predict(sm.add_constant(test.df)).idxmax(axis=1)\n",
    "predicted_values = pd.DataFrame(model.predict(sm.add_constant(test.df)).idxmax(axis=1), index=test.df.index, columns=[0])\n",
    "predicted_y = decode_dep_var(predicted_values)\n",
    "prediction_output = concat_id_and_predictions(test, predicted_y)\n",
    "prediction_output.to_csv('pointon_predictions_Logistic.csv', index=False)\n",
    "prediction_output # region:\n",
    "#\n",
    "# 'water_quality: fluoride abandoned', 'payment_type: per bucket', 'extraction_type_class: rope pump'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 357,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The final kfold confusion matrix: \n",
      " [[0.56592765 0.19719953 0.23687281]\n",
      " [0.10968495 0.62077013 0.26954492]\n",
      " [0.13636364 0.29020979 0.57342657]]\n",
      "The standard confusion matrix: \n",
      " [[0.60730795 0.0046225  0.38806956]\n",
      " [0.15169195 0.01983664 0.82847141]\n",
      " [0.09177314 0.00358367 0.90464319]]\n",
      "List of logit reg possible accuracies using under-sampling: ['0.59', '0.62', '0.59', '0.61', '0.59']\n",
      "Mean accuracy: 60.03% vs the unrestricted model: 69.62%\n",
      "List of MLP possible accuracies using under-sampling: ['0.65', '0.66', '0.66', '0.66', '0.63']\n",
      "Mean accuracy: 65.11% vs the unrestricted model: 71.76%\n",
      "\n",
      "The final kfold confusion matrix: \n",
      " [[0.59894048 0.18214397 0.21891555]\n",
      " [0.12201964 0.63970703 0.23827334]\n",
      " [0.10628019 0.30839956 0.58532024]]\n",
      "The standard confusion matrix: \n",
      " [[0.60730795 0.0046225  0.38806956]\n",
      " [0.15169195 0.01983664 0.82847141]\n",
      " [0.09177314 0.00358367 0.90464319]]\n",
      "List of logit reg possible accuracies using over-sampling: ['0.61', '0.61', '0.61', '0.62', '0.61']\n",
      "Mean accuracy: 61.1% vs the unrestricted model: 69.62%\n",
      "List of MLP possible accuracies using over-sampling: ['0.67', '0.66', '0.66', '0.67', '0.66']\n",
      "Mean accuracy: 66.14% vs the unrestricted model: 71.73%\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Getting an overall test-train split\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train_all, X_test_all, y_train_all, y_test_all = train_test_split(X_train, y_train,\n",
    "                                                    stratify=y_train,\n",
    "                                                    test_size=0.2)\n",
    "# Dealing with the imbalanced classes\n",
    "from imblearn.under_sampling import RandomUnderSampler\n",
    "from imblearn.over_sampling import RandomOverSampler\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "from sklearn.metrics import ConfusionMatrixDisplay\n",
    "from statistics import mean\n",
    "from sklearn.metrics import f1_score\n",
    "import inspect\n",
    "for sampler in [RandomUnderSampler, RandomOverSampler]:\n",
    "    sampler_type = inspect.getmembers(sampler, lambda a:not(inspect.isroutine(a)))[-1][-1]\n",
    "    # Either under- or over- sample the data\n",
    "    if sampler == RandomUnderSampler:\n",
    "        rs = sampler(replacement=False, random_state=0)\n",
    "    else:\n",
    "        rs = RandomOverSampler(random_state=0)\n",
    "    X_resampled, y_resampled = rs.fit_resample(X_train, y_train)\n",
    "\n",
    "    # Kfold sampling but maintaining the equal class balance\n",
    "    f1_scores = []\n",
    "    mlp_f1_scores = []\n",
    "    skf = StratifiedKFold(n_splits=5, shuffle=False)\n",
    "    for train_index, test_index in skf.split(X_resampled, y_resampled):\n",
    "        X_train_kfold, X_test_kfold = X_resampled.iloc[train_index], X_resampled.iloc[test_index]\n",
    "        y_train_kfold, y_test_kfold = y_resampled.iloc[train_index], y_resampled.iloc[test_index]\n",
    "\n",
    "        # Applying the logistic regression model\n",
    "        lr_model = sm.MNLogit(y_train_kfold,sm.add_constant(X_train_kfold)).fit(method='bfgs', maxiter=2000, disp=0) #.fit_regularized(method='l1', maxiter=2000, alpha=5.1)\n",
    "        lr_prediction = lr_model.predict(sm.add_constant(X_test_kfold)).idxmax(axis=1)\n",
    "        f1_scores.append(f1_score(y_test_kfold, lr_prediction, average='weighted'))\n",
    "\n",
    "        # Applying the MLP model\n",
    "        mlp_model = MLPClassifier(hidden_layer_sizes=(100,), max_iter=500, alpha=0.5) # Don't want to be too simple but don't want to overfit - (93inputs + 3outputs)*2/3 as per https://medium.com/geekculture/introduction-to-neural-network-2f8b8221fbd3\n",
    "        mlp_model.fit(X_train_kfold, y_train_kfold)\n",
    "        mlp_prediction = mlp_model.predict(X_test_kfold)\n",
    "        mlp_f1_scores.append(f1_score(y_test_kfold, mlp_prediction, average='weighted'))\n",
    "\n",
    "    # print the final confusion matrix\n",
    "    print('The final kfold confusion matrix: \\n', confusion_matrix(y_test_kfold, lr_prediction, normalize='true'))\n",
    "    cm = confusion_matrix(y_test_kfold, lr_prediction, normalize='true')\n",
    "    disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['non functional', 'semi functional', 'functional'])\n",
    "    disp.ax_.get_images()[0].set_clim(0, 1) # set scale to be [0,1]\n",
    "    disp.plot()\n",
    "    plt.savefig(f'Output/confusion_matrix_kfold_{sampler_type}.png', dpi=1200)\n",
    "\n",
    "    # Applying the models to the full dataset with no under/over sampling and a simple 80:20 train/test split:\n",
    "    lr_model = sm.MNLogit(y_train_all,sm.add_constant(X_train_all)).fit(method='bfgs', maxiter=2000, disp=0) #.fit_regularized(method='l1', maxiter=2000, alpha=5.1)\n",
    "    lr_prediction = lr_model.predict(sm.add_constant(X_test_all)).idxmax(axis=1)\n",
    "    print('The standard confusion matrix: \\n', confusion_matrix(y_test_all, lr_prediction, normalize='true'))\n",
    "    cm = confusion_matrix(y_test_all, lr_prediction, normalize='true')\n",
    "    disp.ax_.get_images()[0].set_clim(0, 1) # set scale to be [0,1]\n",
    "    disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['non functional', 'functional needs repair', 'functional'])\n",
    "    disp.plot()\n",
    "    plt.savefig(f'Output/confusion_matrix_standard_{sampler_type}.png', dpi=1200)\n",
    "\n",
    "    mlp_model = MLPClassifier(hidden_layer_sizes=(100,), max_iter=500, alpha=0.5) # Don't want to be too simple but don't want to overfit - (93inputs + 3outputs)*2/3 as per https://medium.com/geekculture/introduction-to-neural-network-2f8b8221fbd3\n",
    "    mlp_model.fit(X_train_all, y_train_all)\n",
    "    mlp_prediction = mlp_model.predict(X_test_all)\n",
    "\n",
    "    # Summarise and print the output:\n",
    "    print(f'List of logit reg possible accuracies using {sampler_type}:', [\"%.2f\" % num for num in f1_scores])\n",
    "    print(f'Mean accuracy: {round(mean(f1_scores)*100, 2)}% vs the unrestricted model: {round(f1_score(y_test_all, lr_prediction, average=\"weighted\")*100, 2)}%')\n",
    "    print(f'List of MLP possible accuracies using {sampler_type}:', [\"%.2f\" % num for num in mlp_f1_scores])\n",
    "    print(f'Mean accuracy: {round(mean(mlp_f1_scores)*100, 2)}% vs the unrestricted model: {round(f1_score(y_test_all, mlp_prediction, average=\"weighted\")*100, 2)}%\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "y should be a 1d array, got an array of shape (59087, 3) instead.",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[1;32mIn [240]\u001b[0m, in \u001b[0;36m<cell line: 8>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      5\u001b[0m label_binarizer \u001b[38;5;241m=\u001b[39m LabelBinarizer()\u001b[38;5;241m.\u001b[39mfit(y_train)\n\u001b[0;32m      6\u001b[0m y_onehot_train \u001b[38;5;241m=\u001b[39m label_binarizer\u001b[38;5;241m.\u001b[39mtransform(y_train)\n\u001b[1;32m----> 8\u001b[0m \u001b[43mRocCurveDisplay\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfrom_predictions\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m      9\u001b[0m \u001b[43m    \u001b[49m\u001b[43my_onehot_train\u001b[49m\u001b[43m[\u001b[49m\u001b[43m:\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m     10\u001b[0m \u001b[43m    \u001b[49m\u001b[43mtraining_prediction\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m     11\u001b[0m \u001b[43m    \u001b[49m\u001b[43mname\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43mf\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mOne vs the rest\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m     12\u001b[0m \u001b[43m    \u001b[49m\u001b[43mcolor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mdarkorange\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m     13\u001b[0m \u001b[43m)\u001b[49m\n\u001b[0;32m     14\u001b[0m plt\u001b[38;5;241m.\u001b[39mplot([\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m], [\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m], \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mk--\u001b[39m\u001b[38;5;124m\"\u001b[39m, label\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mchance level (AUC = 0.5)\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m     15\u001b[0m plt\u001b[38;5;241m.\u001b[39maxis(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msquare\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\sklearn\\metrics\\_plot\\roc_curve.py:333\u001b[0m, in \u001b[0;36mRocCurveDisplay.from_predictions\u001b[1;34m(cls, y_true, y_pred, sample_weight, drop_intermediate, pos_label, name, ax, **kwargs)\u001b[0m\n\u001b[0;32m    262\u001b[0m \u001b[38;5;124;03m\"\"\"Plot ROC curve given the true and predicted values.\u001b[39;00m\n\u001b[0;32m    263\u001b[0m \n\u001b[0;32m    264\u001b[0m \u001b[38;5;124;03mRead more in the :ref:`User Guide <visualizations>`.\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    329\u001b[0m \u001b[38;5;124;03m>>> plt.show()\u001b[39;00m\n\u001b[0;32m    330\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[0;32m    331\u001b[0m check_matplotlib_support(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mcls\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;18m__name__\u001b[39m\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.from_predictions\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m--> 333\u001b[0m fpr, tpr, _ \u001b[38;5;241m=\u001b[39m \u001b[43mroc_curve\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m    334\u001b[0m \u001b[43m    \u001b[49m\u001b[43my_true\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    335\u001b[0m \u001b[43m    \u001b[49m\u001b[43my_pred\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    336\u001b[0m \u001b[43m    \u001b[49m\u001b[43mpos_label\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpos_label\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    337\u001b[0m \u001b[43m    \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msample_weight\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    338\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdrop_intermediate\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdrop_intermediate\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    339\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    340\u001b[0m roc_auc \u001b[38;5;241m=\u001b[39m auc(fpr, tpr)\n\u001b[0;32m    342\u001b[0m name \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mClassifier\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m name \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m name\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\sklearn\\metrics\\_ranking.py:962\u001b[0m, in \u001b[0;36mroc_curve\u001b[1;34m(y_true, y_score, pos_label, sample_weight, drop_intermediate)\u001b[0m\n\u001b[0;32m    873\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mroc_curve\u001b[39m(\n\u001b[0;32m    874\u001b[0m     y_true, y_score, \u001b[38;5;241m*\u001b[39m, pos_label\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, sample_weight\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, drop_intermediate\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m\n\u001b[0;32m    875\u001b[0m ):\n\u001b[0;32m    876\u001b[0m     \u001b[38;5;124;03m\"\"\"Compute Receiver operating characteristic (ROC).\u001b[39;00m\n\u001b[0;32m    877\u001b[0m \n\u001b[0;32m    878\u001b[0m \u001b[38;5;124;03m    Note: this implementation is restricted to the binary classification task.\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    960\u001b[0m \n\u001b[0;32m    961\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[1;32m--> 962\u001b[0m     fps, tps, thresholds \u001b[38;5;241m=\u001b[39m \u001b[43m_binary_clf_curve\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m    963\u001b[0m \u001b[43m        \u001b[49m\u001b[43my_true\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my_score\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpos_label\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpos_label\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43msample_weight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msample_weight\u001b[49m\n\u001b[0;32m    964\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    966\u001b[0m     \u001b[38;5;66;03m# Attempt to drop thresholds corresponding to points in between and\u001b[39;00m\n\u001b[0;32m    967\u001b[0m     \u001b[38;5;66;03m# collinear with other points. These are always suboptimal and do not\u001b[39;00m\n\u001b[0;32m    968\u001b[0m     \u001b[38;5;66;03m# appear on a plotted ROC curve (and thus do not affect the AUC).\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    973\u001b[0m     \u001b[38;5;66;03m# but does not drop more complicated cases like fps = [1, 3, 7],\u001b[39;00m\n\u001b[0;32m    974\u001b[0m     \u001b[38;5;66;03m# tps = [1, 2, 4]; there is no harm in keeping too many thresholds.\u001b[39;00m\n\u001b[0;32m    975\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m drop_intermediate \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(fps) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m2\u001b[39m:\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\sklearn\\metrics\\_ranking.py:735\u001b[0m, in \u001b[0;36m_binary_clf_curve\u001b[1;34m(y_true, y_score, pos_label, sample_weight)\u001b[0m\n\u001b[0;32m    733\u001b[0m check_consistent_length(y_true, y_score, sample_weight)\n\u001b[0;32m    734\u001b[0m y_true \u001b[38;5;241m=\u001b[39m column_or_1d(y_true)\n\u001b[1;32m--> 735\u001b[0m y_score \u001b[38;5;241m=\u001b[39m \u001b[43mcolumn_or_1d\u001b[49m\u001b[43m(\u001b[49m\u001b[43my_score\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    736\u001b[0m assert_all_finite(y_true)\n\u001b[0;32m    737\u001b[0m assert_all_finite(y_score)\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\sklearn\\utils\\validation.py:1038\u001b[0m, in \u001b[0;36mcolumn_or_1d\u001b[1;34m(y, warn)\u001b[0m\n\u001b[0;32m   1029\u001b[0m         warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[0;32m   1030\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mA column-vector y was passed when a 1d array was\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m   1031\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m expected. Please change the shape of y to \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m   1034\u001b[0m             stacklevel\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m,\n\u001b[0;32m   1035\u001b[0m         )\n\u001b[0;32m   1036\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m np\u001b[38;5;241m.\u001b[39mravel(y)\n\u001b[1;32m-> 1038\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[0;32m   1039\u001b[0m     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124my should be a 1d array, got an array of shape \u001b[39m\u001b[38;5;132;01m{}\u001b[39;00m\u001b[38;5;124m instead.\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mformat(shape)\n\u001b[0;32m   1040\u001b[0m )\n",
      "\u001b[1;31mValueError\u001b[0m: y should be a 1d array, got an array of shape (59087, 3) instead."
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import RocCurveDisplay\n",
    "from sklearn.preprocessing import LabelBinarizer\n",
    "\n",
    "label_binarizer = LabelBinarizer().fit(y_train)\n",
    "y_onehot_train = label_binarizer.transform(y_train)\n",
    "\n",
    "RocCurveDisplay.from_predictions(\n",
    "    y_onehot_train[:, 0],\n",
    "    training_prediction,\n",
    "    name=f\"One vs the rest\",\n",
    ")\n",
    "plt.plot([0, 1], [0, 1], \"k--\", label=\"chance level (AUC = 0.5)\")\n",
    "plt.axis(\"square\")\n",
    "plt.xlabel(\"False Positive Rate\")\n",
    "plt.ylabel(\"True Positive Rate\")\n",
    "plt.title(\"One-vs-Rest ROC curves:\\nVirginica vs (Setosa & Versicolor)\")\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "# fig, ax = plt.subplots(figsize=(6, 6))\n",
    "# from itertools import cycle\n",
    "# n_classes = 3\n",
    "# colors = cycle([\"aqua\", \"darkorange\", \"cornflowerblue\"])\n",
    "# for class_id, color in zip(range(3), colors):\n",
    "#     RocCurveDisplay.from_predictions(\n",
    "#         y_onehot_train[:, class_id],\n",
    "#         training_prediction,\n",
    "#         name=f\"ROC curve for {class_id}\",\n",
    "#         color=color,\n",
    "#         ax=ax,\n",
    "#     )\n",
    "#\n",
    "# plt.plot([0, 1], [0, 1], \"k--\", label=\"ROC curve for chance level (AUC = 0.5)\")\n",
    "# plt.axis(\"square\")\n",
    "# plt.xlabel(\"False Positive Rate\")\n",
    "# plt.ylabel(\"True Positive Rate\")\n",
    "# plt.title(\"Extension of Receiver Operating Characteristic\\nto One-vs-Rest multiclass\")\n",
    "# plt.legend()\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 0, 2, ..., 2, 2, 0], dtype=int64)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "model = RandomForestClassifier()\n",
    "model.fit(X_train, y_train)\n",
    "predicted_y = model.predict(test.df)\n",
    "predicted_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def decode_dep_var(model_predictions):\n",
    "    # Do we want to do these?\n",
    "    model_predictions = pd.DataFrame(model_predictions)\n",
    "    model_predictions['status_group'] = model_predictions[0].replace(0, \"non functional\")\n",
    "    model_predictions['status_group'].replace(1, \"functional needs repair\", inplace=True)\n",
    "    model_predictions['status_group'].replace(2, \"functional\", inplace=True)\n",
    "    model_predictions.drop(columns=[0], inplace=True)\n",
    "    return model_predictions\n",
    "\n",
    "def concat_id_and_predictions(test_object, predictions):\n",
    "    prediction_output = pd.DataFrame()\n",
    "    prediction_output['id'] = test_object.ids\n",
    "    prediction_output['status_group'] = predictions\n",
    "    return prediction_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>id</th>\n",
       "      <th>status_group</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>50785</td>\n",
       "      <td>functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>51630</td>\n",
       "      <td>non functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>17168</td>\n",
       "      <td>functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>45559</td>\n",
       "      <td>non functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>49871</td>\n",
       "      <td>functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14845</th>\n",
       "      <td>39307</td>\n",
       "      <td>non functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14846</th>\n",
       "      <td>18990</td>\n",
       "      <td>functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14847</th>\n",
       "      <td>28749</td>\n",
       "      <td>functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14848</th>\n",
       "      <td>33492</td>\n",
       "      <td>functional</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14849</th>\n",
       "      <td>68707</td>\n",
       "      <td>non functional</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>14850 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "          id    status_group\n",
       "0      50785      functional\n",
       "1      51630  non functional\n",
       "2      17168      functional\n",
       "3      45559  non functional\n",
       "4      49871      functional\n",
       "...      ...             ...\n",
       "14845  39307  non functional\n",
       "14846  18990      functional\n",
       "14847  28749      functional\n",
       "14848  33492      functional\n",
       "14849  68707  non functional\n",
       "\n",
       "[14850 rows x 2 columns]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "predicted_y = decode_dep_var(predicted_y)\n",
    "prediction_output = concat_id_and_predictions(test, predicted_y)\n",
    "prediction_output.to_csv('pointon_predictions_RF.csv', index=False)\n",
    "prediction_output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Regression imputation\n",
    "# for feature in ['amount_tsh', 'population', 'gps_height']: # any others??\n",
    "#     training.regression_imputation(feature)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true       38703\n",
       "false      17341\n",
       "unknown     3043\n",
       "Name: permit, dtype: int64"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "training_df_for_test_imputations['permit'].value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: xlabel='permit', ylabel='status_group'>"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.histplot(data=training_df_for_test_imputations, x='permit', y='status_group')\n",
    "# df['longitude_new'] = df['longitude'].fillna(df.groupby(['region', 'ward'])['longitude'].transform('mean'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# sns.histplot(data=df.loc[df['extraction_type_class'].isin(['other - mkulima/shinyanga', 'climax', 'walimi', 'other - play pump', 'cemo'])], x='extraction_type_class', hue='status_group', stat='percent', multiple=\"dodge\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# sns.histplot(data=df.loc[(df['num_private']>0) & (df['num_private']<100)], x='num_private', hue='status_group', stat='percent', multiple=\"dodge\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# adapted from https://stackoverflow.com/questions/34615854/seaborn-countplot-with-normalized-y-axis-per-group\n",
    "# (df.loc[df['num_private']<10]\n",
    "# .groupby('num_private')['status_group']\n",
    "# .value_counts(normalize=True)\n",
    "# .mul(100)\n",
    "# .rename('percent')\n",
    "# .reset_index()\n",
    "# .pipe((sns.catplot,'data'), x='num_private',y='percent',hue='status_group',kind='bar'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# sns.histplot(data=df, x='region', y='status_group', cbar=True) # distribution/histogram of region vs status_group using the count in each bin - will need to redo the region codes and use these instead of the region column"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from sklearn.impute import KNNImputer\n",
    "# imputer = KNNImputer(n_neighbors=19287)\n",
    "# dummies = pd.get_dummies(df['subvillage']).add_prefix('subvillage'+\": \").iloc[:,:-1]\n",
    "# df = pd.concat([df, dummies], axis=1) # leave last dummy to avoid DV trap\n",
    "# vars = list(dummies) + ['longitude', 'latitude', 'gps_height']\n",
    "# imputer.fit_transform(df[vars])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# sns.boxplot(data=df.loc[(df['amount_tsh']>0) & (df['amount_tsh']<500)], x='amount_tsh')\n",
    "# df.loc[(df['amount_tsh']>0) & (df['amount_tsh']<500)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# df.loc[(df['amount_tsh']>0) & (df['amount_tsh']<400), 'amount_tsh'].quantile(np.linspace(.1, 1, 18, 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Outliers\n",
    "# sns.boxplot(data=df.loc[df['amount_tsh']>10000], x='status_group', y='amount_tsh')\n",
    "# sns.violinplot(data=df, x='status_group', y='amount_tsh') # so there is a correlation between broken/amount_tsh"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: xlabel='status_group', ylabel='population'>"
      ]
     },
     "execution_count": 200,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.violinplot(data=training.df.loc[training.df['population']<600], x='status_group', y='population')\n",
    "# df.loc[df['population']<600, 'population'].describe()\n",
    "# df.loc[df['status_group']=='non functional']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: xlabel='amount_tsh', ylabel='waterpoint_type_group'>"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.boxplot(data=training.df, x='amount_tsh', y='waterpoint_type_group')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "region       ward           \n",
       "tabora       sungwisi             1\n",
       "kigoma       machinjioni          1\n",
       "mara         nyamtinga            1\n",
       "morogoro     uwanja wa ndege      1\n",
       "mtwara       majengo              1\n",
       "                               ... \n",
       "arusha       nduruma            205\n",
       "iringa       mdandu             231\n",
       "kilimanjaro  siha kati          232\n",
       "iringa       imalinyi           252\n",
       "             igosi              307\n",
       "Name: NaNs, Length: 2173, dtype: int64"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# sns.histplot(data=df, x='age')\n",
    "sns.histplot(data=training.df.loc[training.df['population']>10000], x='population')\n",
    "# plt.savefig('Output/dep_var.png', dpi=1200)\n",
    "training.df.loc[training.df['population']>10000, ['population', 'longitude', 'latitude', 'region', 'subvillage', 'ward']]\n",
    "# df['population'].quantile(np.linspace(.1, 1, 99, 0))\n",
    "subdf = training.df.loc[training.df['ward']=='masuguru', ['longitude', 'latitude', 'region', 'ward', 'subvillage', 'population']].sort_values(by=['region', 'ward', 'subvillage']) # impute with the region and ward average!!\n",
    "# df.columns\n",
    "# sum(subdf.loc[subdf['population']<25000,'population'])/len(subdf.loc[subdf['population']<25000,'population'])\n",
    "# subdf\n",
    "training.df.groupby(['region','ward']).count().sort_values('NaNs')['NaNs']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# sns.kdeplot(data=df.loc[df['amount_tsh']<10000], x='amount_tsh', fill=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "KeyboardInterrupt\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error in callback <function flush_figures at 0x000001E79110AEE0> (for post_execute):\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n",
      "KeyboardInterrupt\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# sns.histplot(data=df.loc[df['amount_tsh']>0], x='amount_tsh', bins=10)\n",
    "sns.pairplot(data=training.df, hue='status_group')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>amount_tsh</th>\n",
       "      <th>gps_height</th>\n",
       "      <th>longitude</th>\n",
       "      <th>latitude</th>\n",
       "      <th>population</th>\n",
       "      <th>age</th>\n",
       "      <th>status_group_encoding</th>\n",
       "      <th>NaNs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>amount_tsh</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.068761</td>\n",
       "      <td>-0.168865</td>\n",
       "      <td>-0.154301</td>\n",
       "      <td>0.003255</td>\n",
       "      <td>0.057333</td>\n",
       "      <td>0.052160</td>\n",
       "      <td>-0.276369</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>gps_height</th>\n",
       "      <td>0.068761</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>-0.569910</td>\n",
       "      <td>0.281220</td>\n",
       "      <td>-0.039622</td>\n",
       "      <td>0.021225</td>\n",
       "      <td>0.152932</td>\n",
       "      <td>0.222164</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>longitude</th>\n",
       "      <td>-0.168865</td>\n",
       "      <td>-0.569910</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>-0.308643</td>\n",
       "      <td>-0.097411</td>\n",
       "      <td>-0.035284</td>\n",
       "      <td>-0.005425</td>\n",
       "      <td>-0.482353</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>latitude</th>\n",
       "      <td>-0.154301</td>\n",
       "      <td>0.281220</td>\n",
       "      <td>-0.308643</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.047701</td>\n",
       "      <td>-0.016951</td>\n",
       "      <td>0.015397</td>\n",
       "      <td>0.212746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>population</th>\n",
       "      <td>0.003255</td>\n",
       "      <td>-0.039622</td>\n",
       "      <td>-0.097411</td>\n",
       "      <td>0.047701</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>-0.028382</td>\n",
       "      <td>0.016776</td>\n",
       "      <td>-0.018691</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>age</th>\n",
       "      <td>0.057333</td>\n",
       "      <td>0.021225</td>\n",
       "      <td>-0.035284</td>\n",
       "      <td>-0.016951</td>\n",
       "      <td>-0.028382</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>-0.291744</td>\n",
       "      <td>0.118777</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>status_group_encoding</th>\n",
       "      <td>0.052160</td>\n",
       "      <td>0.152932</td>\n",
       "      <td>-0.005425</td>\n",
       "      <td>0.015397</td>\n",
       "      <td>0.016776</td>\n",
       "      <td>-0.291744</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>-0.051532</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>NaNs</th>\n",
       "      <td>-0.276369</td>\n",
       "      <td>0.222164</td>\n",
       "      <td>-0.482353</td>\n",
       "      <td>0.212746</td>\n",
       "      <td>-0.018691</td>\n",
       "      <td>0.118777</td>\n",
       "      <td>-0.051532</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                       amount_tsh  gps_height  longitude  latitude  \\\n",
       "amount_tsh               1.000000    0.068761  -0.168865 -0.154301   \n",
       "gps_height               0.068761    1.000000  -0.569910  0.281220   \n",
       "longitude               -0.168865   -0.569910   1.000000 -0.308643   \n",
       "latitude                -0.154301    0.281220  -0.308643  1.000000   \n",
       "population               0.003255   -0.039622  -0.097411  0.047701   \n",
       "age                      0.057333    0.021225  -0.035284 -0.016951   \n",
       "status_group_encoding    0.052160    0.152932  -0.005425  0.015397   \n",
       "NaNs                    -0.276369    0.222164  -0.482353  0.212746   \n",
       "\n",
       "                       population       age  status_group_encoding      NaNs  \n",
       "amount_tsh               0.003255  0.057333               0.052160 -0.276369  \n",
       "gps_height              -0.039622  0.021225               0.152932  0.222164  \n",
       "longitude               -0.097411 -0.035284              -0.005425 -0.482353  \n",
       "latitude                 0.047701 -0.016951               0.015397  0.212746  \n",
       "population               1.000000 -0.028382               0.016776 -0.018691  \n",
       "age                     -0.028382  1.000000              -0.291744  0.118777  \n",
       "status_group_encoding    0.016776 -0.291744               1.000000 -0.051532  \n",
       "NaNs                    -0.018691  0.118777              -0.051532  1.000000  "
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Correlation between the variables\n",
    "training.df.corr()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: >"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1080x1080 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Let's turn this correlation into a heatmap\n",
    "plt.figure(figsize=(10,10))\n",
    "sns.heatmap(training.df.corr(), cmap=sns.cubehelix_palette(as_cmap=True), annot=True) # , mask = (np.abs(df.corr() ) >= 0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sns.set(style=\"ticks\", color_codes=True)\n",
    "# sns.pairplot(df.select_dtypes(include=np.number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "JB's work"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\point\\anaconda3\\lib\\site-packages\\pyproj\\crs\\crs.py:141: FutureWarning: '+init=<authority>:<code>' syntax is deprecated. '<authority>:<code>' is the preferred initialization method. When making the change, be mindful of axis order changes: https://pyproj4.github.io/pyproj/stable/gotchas.html#axis-order-changes-in-proj-6\n",
      "  in_crs_string = _prepare_from_proj_string(in_crs_string)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "training.get_geo_graphic()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Input contains NaN, infinity or a value too large for dtype('float64').",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[1;32mIn [217]\u001b[0m, in \u001b[0;36m<cell line: 7>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      5\u001b[0m pointon_x \u001b[38;5;241m=\u001b[39m pointon\u001b[38;5;241m.\u001b[39mdf\u001b[38;5;241m.\u001b[39mloc[:,pointon\u001b[38;5;241m.\u001b[39mdf\u001b[38;5;241m.\u001b[39mcolumns \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mstatus_group_encoding\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[0;32m      6\u001b[0m pointon_y \u001b[38;5;241m=\u001b[39m pointon\u001b[38;5;241m.\u001b[39mdf[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mstatus_group_encoding\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[1;32m----> 7\u001b[0m \u001b[43mmodel\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfit\u001b[49m\u001b[43m(\u001b[49m\u001b[43mX\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mpointon_x\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mpointon_y\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m      9\u001b[0m predicted_values \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mDataFrame(model\u001b[38;5;241m.\u001b[39mpredict(pointon_x), index\u001b[38;5;241m=\u001b[39mpointon_x\u001b[38;5;241m.\u001b[39mindex, columns\u001b[38;5;241m=\u001b[39m[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mprediction\u001b[39m\u001b[38;5;124m'\u001b[39m])\n\u001b[0;32m     10\u001b[0m pointon\u001b[38;5;241m.\u001b[39mdf \u001b[38;5;241m=\u001b[39m pointon\u001b[38;5;241m.\u001b[39mdf\u001b[38;5;241m.\u001b[39mjoin(predicted_values)\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\sklearn\\linear_model\\_logistic.py:1508\u001b[0m, in \u001b[0;36mLogisticRegression.fit\u001b[1;34m(self, X, y, sample_weight)\u001b[0m\n\u001b[0;32m   1505\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m   1506\u001b[0m     _dtype \u001b[38;5;241m=\u001b[39m [np\u001b[38;5;241m.\u001b[39mfloat64, np\u001b[38;5;241m.\u001b[39mfloat32]\n\u001b[1;32m-> 1508\u001b[0m X, y \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_validate_data\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m   1509\u001b[0m \u001b[43m    \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1510\u001b[0m \u001b[43m    \u001b[49m\u001b[43my\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1511\u001b[0m \u001b[43m    \u001b[49m\u001b[43maccept_sparse\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mcsr\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1512\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m_dtype\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1513\u001b[0m \u001b[43m    \u001b[49m\u001b[43morder\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mC\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1514\u001b[0m \u001b[43m    \u001b[49m\u001b[43maccept_large_sparse\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msolver\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mliblinear\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43msag\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43msaga\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m   1515\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1516\u001b[0m check_classification_targets(y)\n\u001b[0;32m   1517\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mclasses_ \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39munique(y)\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\sklearn\\base.py:581\u001b[0m, in \u001b[0;36mBaseEstimator._validate_data\u001b[1;34m(self, X, y, reset, validate_separately, **check_params)\u001b[0m\n\u001b[0;32m    579\u001b[0m         y \u001b[38;5;241m=\u001b[39m check_array(y, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mcheck_y_params)\n\u001b[0;32m    580\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m--> 581\u001b[0m         X, y \u001b[38;5;241m=\u001b[39m check_X_y(X, y, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mcheck_params)\n\u001b[0;32m    582\u001b[0m     out \u001b[38;5;241m=\u001b[39m X, y\n\u001b[0;32m    584\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m no_val_X \u001b[38;5;129;01mand\u001b[39;00m check_params\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mensure_2d\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mTrue\u001b[39;00m):\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\sklearn\\utils\\validation.py:964\u001b[0m, in \u001b[0;36mcheck_X_y\u001b[1;34m(X, y, accept_sparse, accept_large_sparse, dtype, order, copy, force_all_finite, ensure_2d, allow_nd, multi_output, ensure_min_samples, ensure_min_features, y_numeric, estimator)\u001b[0m\n\u001b[0;32m    961\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m y \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m    962\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124my cannot be None\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m--> 964\u001b[0m X \u001b[38;5;241m=\u001b[39m \u001b[43mcheck_array\u001b[49m\u001b[43m(\u001b[49m\n\u001b[0;32m    965\u001b[0m \u001b[43m    \u001b[49m\u001b[43mX\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    966\u001b[0m \u001b[43m    \u001b[49m\u001b[43maccept_sparse\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maccept_sparse\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    967\u001b[0m \u001b[43m    \u001b[49m\u001b[43maccept_large_sparse\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43maccept_large_sparse\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    968\u001b[0m \u001b[43m    \u001b[49m\u001b[43mdtype\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdtype\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    969\u001b[0m \u001b[43m    \u001b[49m\u001b[43morder\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43morder\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    970\u001b[0m \u001b[43m    \u001b[49m\u001b[43mcopy\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcopy\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    971\u001b[0m \u001b[43m    \u001b[49m\u001b[43mforce_all_finite\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mforce_all_finite\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    972\u001b[0m \u001b[43m    \u001b[49m\u001b[43mensure_2d\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mensure_2d\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    973\u001b[0m \u001b[43m    \u001b[49m\u001b[43mallow_nd\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mallow_nd\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    974\u001b[0m \u001b[43m    \u001b[49m\u001b[43mensure_min_samples\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mensure_min_samples\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    975\u001b[0m \u001b[43m    \u001b[49m\u001b[43mensure_min_features\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mensure_min_features\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    976\u001b[0m \u001b[43m    \u001b[49m\u001b[43mestimator\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mestimator\u001b[49m\u001b[43m,\u001b[49m\n\u001b[0;32m    977\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    979\u001b[0m y \u001b[38;5;241m=\u001b[39m _check_y(y, multi_output\u001b[38;5;241m=\u001b[39mmulti_output, y_numeric\u001b[38;5;241m=\u001b[39my_numeric)\n\u001b[0;32m    981\u001b[0m check_consistent_length(X, y)\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\sklearn\\utils\\validation.py:800\u001b[0m, in \u001b[0;36mcheck_array\u001b[1;34m(array, accept_sparse, accept_large_sparse, dtype, order, copy, force_all_finite, ensure_2d, allow_nd, ensure_min_samples, ensure_min_features, estimator)\u001b[0m\n\u001b[0;32m    794\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[0;32m    795\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFound array with dim \u001b[39m\u001b[38;5;132;01m%d\u001b[39;00m\u001b[38;5;124m. \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m expected <= 2.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m    796\u001b[0m             \u001b[38;5;241m%\u001b[39m (array\u001b[38;5;241m.\u001b[39mndim, estimator_name)\n\u001b[0;32m    797\u001b[0m         )\n\u001b[0;32m    799\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m force_all_finite:\n\u001b[1;32m--> 800\u001b[0m         \u001b[43m_assert_all_finite\u001b[49m\u001b[43m(\u001b[49m\u001b[43marray\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mallow_nan\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mforce_all_finite\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m==\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mallow-nan\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m    802\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m ensure_min_samples \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[0;32m    803\u001b[0m     n_samples \u001b[38;5;241m=\u001b[39m _num_samples(array)\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\sklearn\\utils\\validation.py:114\u001b[0m, in \u001b[0;36m_assert_all_finite\u001b[1;34m(X, allow_nan, msg_dtype)\u001b[0m\n\u001b[0;32m    107\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m (\n\u001b[0;32m    108\u001b[0m         allow_nan\n\u001b[0;32m    109\u001b[0m         \u001b[38;5;129;01mand\u001b[39;00m np\u001b[38;5;241m.\u001b[39misinf(X)\u001b[38;5;241m.\u001b[39many()\n\u001b[0;32m    110\u001b[0m         \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m allow_nan\n\u001b[0;32m    111\u001b[0m         \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m np\u001b[38;5;241m.\u001b[39misfinite(X)\u001b[38;5;241m.\u001b[39mall()\n\u001b[0;32m    112\u001b[0m     ):\n\u001b[0;32m    113\u001b[0m         type_err \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124minfinity\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m allow_nan \u001b[38;5;28;01melse\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mNaN, infinity\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m--> 114\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[0;32m    115\u001b[0m             msg_err\u001b[38;5;241m.\u001b[39mformat(\n\u001b[0;32m    116\u001b[0m                 type_err, msg_dtype \u001b[38;5;28;01mif\u001b[39;00m msg_dtype \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m X\u001b[38;5;241m.\u001b[39mdtype\n\u001b[0;32m    117\u001b[0m             )\n\u001b[0;32m    118\u001b[0m         )\n\u001b[0;32m    119\u001b[0m \u001b[38;5;66;03m# for object dtype data, we only check for NaNs (GH-13254)\u001b[39;00m\n\u001b[0;32m    120\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m X\u001b[38;5;241m.\u001b[39mdtype \u001b[38;5;241m==\u001b[39m np\u001b[38;5;241m.\u001b[39mdtype(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mobject\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m allow_nan:\n",
      "\u001b[1;31mValueError\u001b[0m: Input contains NaN, infinity or a value too large for dtype('float64')."
     ]
    }
   ],
   "source": [
    "# JP's analysis\n",
    "pointon = copy.deepcopy(training)\n",
    "# define the multinomial logistic regression model\n",
    "model = linear_model.LogisticRegression(multi_class='multinomial', solver='lbfgs')\n",
    "pointon_x = pointon.df.loc[:,pointon.df.columns != 'status_group_encoding']\n",
    "pointon_y = pointon.df['status_group_encoding']\n",
    "model.fit(X = pointon_x, y = pointon_y)\n",
    "\n",
    "predicted_values = pd.DataFrame(model.predict(pointon_x), index=pointon_x.index, columns=['prediction'])\n",
    "pointon.df = pointon.df.join(predicted_values)\n",
    "pointon.df['Accurate prediction'] = np.where(pointon.df['status_group_encoding']==pointon.df['prediction'], 1, 0)\n",
    "\n",
    "# summarize the predicted class\n",
    "print('Prediction Accuracy: %d' % pointon['Accurate prediction'].mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# probit model\n",
    "# import statsmodels.api as smf\n",
    "# probit_model=smf.Probit(y,X)\n",
    "# result=probit_model.fit()\n",
    "# print(result.summary2())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pca = PCA().fit(pointon.df.dropna())\n",
    "plt.plot(np.cumsum(pca.explained_variance_ratio_))\n",
    "plt.xlabel('number of components')\n",
    "plt.ylabel('cumulative explained variance');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "41"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pca = PCA(0.95).fit(pointon.df.dropna())\n",
    "pca.n_components_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.45232608 1.55117358]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[-0.22099343, -1.07549907],\n",
       "       [ 0.22836442,  2.04594757],\n",
       "       [ 1.74592172, -0.53561159],\n",
       "       ...,\n",
       "       [ 0.64079041, -2.11352072],\n",
       "       [-1.95363224,  0.25185421],\n",
       "       [ 0.65782794, -2.03414563]])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# exclude cols with too many (or only 1) categories\n",
    "pca = PCA(n_components=2)\n",
    "pca.fit(pointon_x.dropna())\n",
    "print(pca.explained_variance_)\n",
    "X_pca = pca.transform(pointon_x.dropna())\n",
    "X_pca"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.cluster import KMeans\n",
    "Kmean = KMeans(n_clusters=3)\n",
    "Kmean.fit(X_pca)\n",
    "plt.scatter(X_pca[ : , 0], X_pca[ : , 1], s =50, c=Kmean.labels_.astype(float))\n",
    "# plt.scatter(-0.94665068, -0.97138368, s=200, c='g', marker=’s’)\n",
    "# plt.scatter(2.01559419, 2.02597093, s=200, c=’r’, marker=’s’)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# from sklearn.cross_decomposition import PLSRegression\n",
    "# pls = PLSRegression(n_components=1) # multi_class='multinomial', solver='lbfgs'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>amount_tsh</th>\n",
       "      <th>gps_height</th>\n",
       "      <th>longitude</th>\n",
       "      <th>latitude</th>\n",
       "      <th>population</th>\n",
       "      <th>age</th>\n",
       "      <th>status_group_encoding</th>\n",
       "      <th>NaNs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>12885.000000</td>\n",
       "      <td>38916.000000</td>\n",
       "      <td>59149.000000</td>\n",
       "      <td>59149.000000</td>\n",
       "      <td>37973.000000</td>\n",
       "      <td>38648.000000</td>\n",
       "      <td>59149.000000</td>\n",
       "      <td>59149.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>66.543489</td>\n",
       "      <td>1021.246659</td>\n",
       "      <td>35.106556</td>\n",
       "      <td>-5.802805</td>\n",
       "      <td>281.218234</td>\n",
       "      <td>15.354067</td>\n",
       "      <td>1.158921</td>\n",
       "      <td>1.889482</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>88.665822</td>\n",
       "      <td>609.806565</td>\n",
       "      <td>2.586687</td>\n",
       "      <td>2.816635</td>\n",
       "      <td>564.993112</td>\n",
       "      <td>12.487614</td>\n",
       "      <td>0.949796</td>\n",
       "      <td>1.647714</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>29.607122</td>\n",
       "      <td>-11.649440</td>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>5.000000</td>\n",
       "      <td>394.000000</td>\n",
       "      <td>33.280764</td>\n",
       "      <td>-8.555373</td>\n",
       "      <td>40.000000</td>\n",
       "      <td>5.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>30.000000</td>\n",
       "      <td>1167.500000</td>\n",
       "      <td>34.926411</td>\n",
       "      <td>-5.043410</td>\n",
       "      <td>150.000000</td>\n",
       "      <td>13.000000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>1.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>100.000000</td>\n",
       "      <td>1499.000000</td>\n",
       "      <td>37.180494</td>\n",
       "      <td>-3.333518</td>\n",
       "      <td>324.000000</td>\n",
       "      <td>25.000000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>4.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>400.000000</td>\n",
       "      <td>2770.000000</td>\n",
       "      <td>40.345193</td>\n",
       "      <td>-0.998464</td>\n",
       "      <td>30500.000000</td>\n",
       "      <td>53.000000</td>\n",
       "      <td>2.000000</td>\n",
       "      <td>6.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         amount_tsh    gps_height     longitude      latitude    population  \\\n",
       "count  12885.000000  38916.000000  59149.000000  59149.000000  37973.000000   \n",
       "mean      66.543489   1021.246659     35.106556     -5.802805    281.218234   \n",
       "std       88.665822    609.806565      2.586687      2.816635    564.993112   \n",
       "min        0.000000      1.000000     29.607122    -11.649440      1.000000   \n",
       "25%        5.000000    394.000000     33.280764     -8.555373     40.000000   \n",
       "50%       30.000000   1167.500000     34.926411     -5.043410    150.000000   \n",
       "75%      100.000000   1499.000000     37.180494     -3.333518    324.000000   \n",
       "max      400.000000   2770.000000     40.345193     -0.998464  30500.000000   \n",
       "\n",
       "                age  status_group_encoding          NaNs  \n",
       "count  38648.000000           59149.000000  59149.000000  \n",
       "mean      15.354067               1.158921      1.889482  \n",
       "std       12.487614               0.949796      1.647714  \n",
       "min        0.000000               0.000000      0.000000  \n",
       "25%        5.000000               0.000000      1.000000  \n",
       "50%       13.000000               2.000000      1.000000  \n",
       "75%       25.000000               2.000000      4.000000  \n",
       "max       53.000000               2.000000      6.000000  "
      ]
     },
     "execution_count": 235,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "training.df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "RasterioIOError",
     "evalue": "af_dem_3_3.tif: No such file or directory",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\xarray\\backends\\file_manager.py:199\u001b[0m, in \u001b[0;36mCachingFileManager._acquire_with_cache_info\u001b[1;34m(self, needs_lock)\u001b[0m\n\u001b[0;32m    198\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m--> 199\u001b[0m     file \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_cache\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_key\u001b[49m\u001b[43m]\u001b[49m\n\u001b[0;32m    200\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m:\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\xarray\\backends\\lru_cache.py:53\u001b[0m, in \u001b[0;36mLRUCache.__getitem__\u001b[1;34m(self, key)\u001b[0m\n\u001b[0;32m     52\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_lock:\n\u001b[1;32m---> 53\u001b[0m     value \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_cache\u001b[49m\u001b[43m[\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m]\u001b[49m\n\u001b[0;32m     54\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_cache\u001b[38;5;241m.\u001b[39mmove_to_end(key)\n",
      "\u001b[1;31mKeyError\u001b[0m: [<function open at 0x000001E846E78D30>, ('af_dem_3_3.tif',), 'r', (('sharing', False),)]",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[1;31mCPLE_OpenFailedError\u001b[0m                      Traceback (most recent call last)",
      "File \u001b[1;32mrasterio\\_base.pyx:308\u001b[0m, in \u001b[0;36mrasterio._base.DatasetBase.__init__\u001b[1;34m()\u001b[0m\n",
      "File \u001b[1;32mrasterio\\_base.pyx:219\u001b[0m, in \u001b[0;36mrasterio._base.open_dataset\u001b[1;34m()\u001b[0m\n",
      "File \u001b[1;32mrasterio\\_err.pyx:221\u001b[0m, in \u001b[0;36mrasterio._err.exc_wrap_pointer\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;31mCPLE_OpenFailedError\u001b[0m: af_dem_3_3.tif: No such file or directory",
      "\nDuring handling of the above exception, another exception occurred:\n",
      "\u001b[1;31mRasterioIOError\u001b[0m                           Traceback (most recent call last)",
      "Input \u001b[1;32mIn [266]\u001b[0m, in \u001b[0;36m<cell line: 3>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mrioxarray\u001b[39;00m  \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mrxr\u001b[39;00m\n\u001b[1;32m----> 3\u001b[0m dataarray \u001b[38;5;241m=\u001b[39m \u001b[43mrxr\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mopen_rasterio\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43maf_dem_3_3.tif\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[0;32m      5\u001b[0m df \u001b[38;5;241m=\u001b[39m dataarray[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mto_pandas()\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\rioxarray\\_io.py:1087\u001b[0m, in \u001b[0;36mopen_rasterio\u001b[1;34m(filename, parse_coordinates, chunks, cache, lock, masked, mask_and_scale, variable, group, default_name, decode_times, decode_timedelta, band_as_variable, **open_kwargs)\u001b[0m\n\u001b[0;32m   1085\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m   1086\u001b[0m         manager \u001b[38;5;241m=\u001b[39m URIManager(file_opener, filename, mode\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m\"\u001b[39m, kwargs\u001b[38;5;241m=\u001b[39mopen_kwargs)\n\u001b[1;32m-> 1087\u001b[0m     riods \u001b[38;5;241m=\u001b[39m \u001b[43mmanager\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43macquire\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   1088\u001b[0m     captured_warnings \u001b[38;5;241m=\u001b[39m rio_warnings\u001b[38;5;241m.\u001b[39mcopy()\n\u001b[0;32m   1090\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m band_as_variable:\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\xarray\\backends\\file_manager.py:181\u001b[0m, in \u001b[0;36mCachingFileManager.acquire\u001b[1;34m(self, needs_lock)\u001b[0m\n\u001b[0;32m    166\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21macquire\u001b[39m(\u001b[38;5;28mself\u001b[39m, needs_lock\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m):\n\u001b[0;32m    167\u001b[0m     \u001b[38;5;124;03m\"\"\"Acquire a file object from the manager.\u001b[39;00m\n\u001b[0;32m    168\u001b[0m \n\u001b[0;32m    169\u001b[0m \u001b[38;5;124;03m    A new file is only opened if it has expired from the\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    179\u001b[0m \u001b[38;5;124;03m        An open file object, as returned by ``opener(*args, **kwargs)``.\u001b[39;00m\n\u001b[0;32m    180\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[1;32m--> 181\u001b[0m     file, _ \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_acquire_with_cache_info\u001b[49m\u001b[43m(\u001b[49m\u001b[43mneeds_lock\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    182\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m file\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\xarray\\backends\\file_manager.py:205\u001b[0m, in \u001b[0;36mCachingFileManager._acquire_with_cache_info\u001b[1;34m(self, needs_lock)\u001b[0m\n\u001b[0;32m    203\u001b[0m     kwargs \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mcopy()\n\u001b[0;32m    204\u001b[0m     kwargs[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mmode\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_mode\n\u001b[1;32m--> 205\u001b[0m file \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_opener(\u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_args, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    206\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_mode \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mw\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m    207\u001b[0m     \u001b[38;5;66;03m# ensure file doesn't get overriden when opened again\u001b[39;00m\n\u001b[0;32m    208\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_mode \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124ma\u001b[39m\u001b[38;5;124m\"\u001b[39m\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\rasterio\\env.py:451\u001b[0m, in \u001b[0;36mensure_env_with_credentials.<locals>.wrapper\u001b[1;34m(*args, **kwds)\u001b[0m\n\u001b[0;32m    448\u001b[0m     session \u001b[38;5;241m=\u001b[39m DummySession()\n\u001b[0;32m    450\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m env_ctor(session\u001b[38;5;241m=\u001b[39msession):\n\u001b[1;32m--> 451\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m f(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwds)\n",
      "File \u001b[1;32m~\\anaconda3\\lib\\site-packages\\rasterio\\__init__.py:334\u001b[0m, in \u001b[0;36mopen\u001b[1;34m(fp, mode, driver, width, height, count, crs, transform, dtype, nodata, sharing, **kwargs)\u001b[0m\n\u001b[0;32m    331\u001b[0m path \u001b[38;5;241m=\u001b[39m _parse_path(raw_dataset_path)\n\u001b[0;32m    333\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m mode \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m--> 334\u001b[0m     dataset \u001b[38;5;241m=\u001b[39m DatasetReader(path, driver\u001b[38;5;241m=\u001b[39mdriver, sharing\u001b[38;5;241m=\u001b[39msharing, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[0;32m    335\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m mode \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mr+\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[0;32m    336\u001b[0m     dataset \u001b[38;5;241m=\u001b[39m get_writer_for_path(path, driver\u001b[38;5;241m=\u001b[39mdriver)(\n\u001b[0;32m    337\u001b[0m         path, mode, driver\u001b[38;5;241m=\u001b[39mdriver, sharing\u001b[38;5;241m=\u001b[39msharing, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs\n\u001b[0;32m    338\u001b[0m     )\n",
      "File \u001b[1;32mrasterio\\_base.pyx:310\u001b[0m, in \u001b[0;36mrasterio._base.DatasetBase.__init__\u001b[1;34m()\u001b[0m\n",
      "\u001b[1;31mRasterioIOError\u001b[0m: af_dem_3_3.tif: No such file or directory"
     ]
    }
   ],
   "source": [
    "# import rioxarray  as rxr\n",
    "#\n",
    "# dataarray = rxr.open_rasterio('af_dem_3_3.tif')\n",
    "#\n",
    "# df = dataarray[0].to_pandas()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}