{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "OfficeDM-Ensemble.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "58MZnL_EcKQ3",
        "colab_type": "text"
      },
      "source": [
        "The information contained in this csv file was taken from actual office records. The exact date of birth within the month was randomly changed for all entries due to HIPAA regulations. \n",
        "BMI is Body Mass Index. The next two columns are Date of Birth and Sex. The columns which follow represent whether there was the presence of non-insulin \n",
        "dependent diabetes mellitus, insulin dependent diabetes melitus, peripheral vascular disease (as evidenced by one or two non-palpable pedal pulses, \n",
        "skin atrophy, decreased hair, and nail changes), neuropathy (as evidenced by decreased sensation of the 5.07 Semmes-Weinstein monofilament fiber), \n",
        "the presence of hyperkeratosis (callus), the presence of an ulcer, the presence of cellulitis, and the first dates that these occurred. 'M' is male, \n",
        "'F' is female, 'Y' is yes, 'N' is no. Within the 'Smoking' column 'N' is never smoked, 'F' is former smoker, 'C' is current smoker, \n",
        "and 'E' means no data was available.\n",
        "\n",
        "The purpose of this study is to compare how various classifiers compare and  can be utilized as part of an supervised learning model for an office setting. The results utilizing two ensemble classifiers (voting and random forest) are also given. At the end there is a summary of the results from each of the classifiers.\n",
        "\n",
        "There was no retrievable data on previous history of ulceration or cellulitis.\n",
        "Instead of NIDDM and IDDM columns there could have been a column for one or the other with a 1 representing the presence of that type and a 0 representing the absence. This would be possible since only diabetics were included in this study. Fitting the model on data that contains that information regarding\n",
        "first ulceration date or first cellulitis date would have produced more accurate results. In addition, only approximately 760 records of diabetic patients were available.\n",
        "\n",
        "This file demonstrates how various classifiers can be utilized in an a clinical setting. A larger data set would increase the accuracy of the model. Please refer to the file where a keras model was utilized and demonstrated worse results due to the small size of the data set. The results could be different with a much larger data set. This larger data set could be obtained from a larger office or from an amalgamation of offices. In addition, the EHR could be specifically designed to capture the information which will be utilized in creating the data set. The target is the 'Ulcer' column with the goal of the model being the identification of those diabetic patients likely to develop ulcerations.These patients would then receive supplemental instructions and observation.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PKmf9pxCZ6D0",
        "colab_type": "code",
        "outputId": "388cadda-ab79-44a3-f1eb-6aee03009c24",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 497
        }
      },
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import datetime as dt\n",
        "from datetime import timedelta\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "# The is file opened as a DataFrame, the first 5 rows are observed, and the data type of each column is determined.\n",
        "df = pd.read_csv(r'https://raw.githubusercontent.com/DavidNNussbaum/office-diabetics/master/OfficeDiabetics.csv')\n",
        "print(df.head())  \n",
        "print(df.dtypes)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "    BMI         DOB Sex  ... Unnamed: 13 Unnamed: 14 Unnamed: 15\n",
            "0  28.2  10/11/1938   F  ...         NaN         NaN         NaN\n",
            "1         6/14/1957   F  ...         NaN         NaN         NaN\n",
            "2  40.7   4/23/1966   M  ...         NaN         NaN         NaN\n",
            "3  38.4   3/11/1967   F  ...         NaN         NaN         NaN\n",
            "4  29.8  10/14/1939   M  ...         NaN         NaN         NaN\n",
            "\n",
            "[5 rows x 16 columns]\n",
            "BMI                 object\n",
            "DOB                 object\n",
            "Sex                 object\n",
            "NIDDM               object\n",
            "IDDM                object\n",
            "PVD                 object\n",
            "Neuro               object\n",
            "Hyper               object\n",
            "Ulcer               object\n",
            "Cellulitis          object\n",
            "Ulcer Date          object\n",
            "Smoking             object\n",
            "Cellulitis Date     object\n",
            "Unnamed: 13        float64\n",
            "Unnamed: 14        float64\n",
            "Unnamed: 15         object\n",
            "dtype: object\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
            "  import pandas.util.testing as tm\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OY3vxnMnfhyx",
        "colab_type": "code",
        "outputId": "9f7d0481-8ae7-4b6b-f8e7-aaf7d3943fe8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 159
        }
      },
      "source": [
        "# Eliminate 'Unnamed' columns.\n",
        "df = df.loc[:, ~df.columns.str.contains('^Unnamed')]\n",
        "# Eliminate any white spaces in column names\n",
        "for column_name in df.columns:\n",
        "    try:\n",
        "        df[column_name] = df[column_name].str.strip()\n",
        "    except AttributeError:  #This means that this error won't stop it\n",
        "        pass\n",
        "print(df.head())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "    BMI         DOB Sex NIDDM  ... Cellulitis Ulcer Date Smoking Cellulitis Date\n",
            "0  28.2  10/11/1938   F     Y  ...        NaN        NaN       F             NaN\n",
            "1         6/14/1957   F   NaN  ...        NaN        NaN       N             NaN\n",
            "2  40.7   4/23/1966   M     Y  ...        NaN        NaN       C             NaN\n",
            "3  38.4   3/11/1967   F   NaN  ...          Y        NaN       N       5/20/2019\n",
            "4  29.8  10/14/1939   M     Y  ...        NaN        NaN       C             NaN\n",
            "\n",
            "[5 rows x 13 columns]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Vr0oyziggVLG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Replace the areas where there are no entries with 0 and a \"Y\" with a 1 in 6 of the columns.  \n",
        "# Note that there was one entry in the 'Ulcer' column which was 'I' but should have been 'Y'. This is being corrected. \n",
        "# Those with no entry (either NaN or nothing) in the 'Smoking' column were replaced with 'E'. \n",
        "# df['Column Name'].unique() was used later on when it was indicated that there were non-integers. These are being corrected here.\n",
        "# In the 'Sex' column replace 'F' with 0 and 'M' with 1.\n",
        "df['NIDDM'] = df['NIDDM'].replace(np.NaN, 0, regex=True) \n",
        "df['NIDDM'] = df['NIDDM'].replace('Y', 1, regex=True) \n",
        "df['IDDM'] = df['IDDM'].replace(np.NaN, 0, regex=True) \n",
        "df['IDDM'] = df['IDDM'].replace('nan', 0, regex=True) \n",
        "df['IDDM'] = df['IDDM'].replace('Y', 1, regex=True) \n",
        "df['PVD'] = df['PVD'].replace(np.NaN, 0, regex=True) \n",
        "df['PVD'] = df['PVD'].replace('Y', 1, regex=True) \n",
        "df['PVD'] = df['PVD'].replace('nan', 0, regex=True) \n",
        "df['Neuro'] = df['Neuro'].replace(np.NaN, 0, regex=True)\n",
        "df['Neuro'] = df['Neuro'].replace('Y', 1, regex=True)  \n",
        "df['Neuro'] = df['Neuro'].replace('nan', 0, regex=True) \n",
        "df['Hyper'] = df['Hyper'].replace(np.NaN, 0, regex=True)\n",
        "df['Hyper'] = df['Hyper'].replace('Y', 1, regex=True) \n",
        "df['Hyper'] = df['Hyper'].replace('nan', 0, regex=True) \n",
        "df['Ulcer'] = df['Ulcer'].replace(np.NaN, 0, regex=True)\n",
        "df['Ulcer'] = df['Ulcer'].replace('I', 1, regex=True)\n",
        "df['Ulcer'] = df['Ulcer'].replace('', 0, regex=True)\n",
        "df['Ulcer'] = df['Ulcer'].replace('Y', 1, regex=True)\n",
        "df['Sex'] = df['Sex'].replace('F', 0, regex=True)\n",
        "df['Sex'] = df['Sex'].replace('M', 1, regex=True)\n",
        "df['Cellulitis'] = df['Cellulitis'].replace(np.NaN, 0, regex=True) \n",
        "df['Cellulitis'] = df['Cellulitis'].replace('Y', 1, regex=True) \n",
        "df['Cellulitis'] = df['Cellulitis'].replace('nan', 0, regex=True) \n",
        "df['Smoking'] = df['Smoking'].replace(np.NaN, 'E', regex=True) \n",
        "df['Smoking'] = df['Smoking'].replace('', 'E', regex=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KVtdKmYCs5Jb",
        "colab_type": "text"
      },
      "source": [
        "In the assembling of the ensemble there was an error message regarding the presence of non-integers. If the data set had been larger those rows would just have been dropped. Since there are only 761 rows, and the correct information was obtainable, the non-integers were corrected. The first two codes (which are now commented out) were used to respectively determine the number of rows and names of the columns.) The third and fourth codes (also commented out)\n",
        "were used to consecutively print 50 rows at a time (printing more than 50 rows would not have allowed all of them to be visible) bringing up rows to examine them. The columns were divided so that all would be visable. The corrections were then made.\n",
        "The 'Ulcer Date', 'Smoking' and \"Cellulitis Date' columns will be dealt with later."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0FR5rulhnIMv",
        "colab_type": "code",
        "outputId": "9627cae6-76f3-4f30-d21c-43a167f729bb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 106
        }
      },
      "source": [
        "# print(df.shape)\n",
        "# print(df.columns)\n",
        "# print(df.loc[0:50, 'DOB':'Neuro'])\n",
        "# print(df.loc[0:50, 'Hyper':'Cellulitis'])\n",
        "df['DOB'].loc[397] = '12/11/1955'\n",
        "df['DOB'].loc[400] = '02/07/1946'\n",
        "df['DOB'].loc[529] = '02/04/1957'\n",
        "df['DOB'].loc[541] = '02/19/1929'\n",
        "df['PVD'].loc[[18, 122, 215]] = 0\n",
        "df['PVD'].loc[[147]] = 1\n",
        "df['Hyper'].loc[215, 217] = 0\n",
        "df['Hyper'].loc[147, 274] = 1\n",
        "df['IDDM'].loc[[18, 292, 427, 526, 543]] = 0\n",
        "df['Neuro'].loc[[526, 533, 543]] = 0\n",
        "df['Cellulitis'].loc[[5, 93, 110, 140, 481]] = 1\n",
        "df['Cellulitis'].loc[[292, 307, 732]] = 0"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/pandas/core/indexing.py:671: SettingWithCopyWarning: \n",
            "A value is trying to be set on a copy of a slice from a DataFrame\n",
            "\n",
            "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
            "  self._setitem_with_indexer(indexer, value)\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YP13IUp0iQ0g",
        "colab_type": "code",
        "outputId": "78245ad6-365c-4551-dc59-b65d1e6487ee",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 230
        }
      },
      "source": [
        "# Fill in blanks in the 'Ulcer Date' and the 'Cellulitis Date' columns with one of the last data retrieval dates.\n",
        "df['Ulcer Date'] = df['Ulcer Date'].replace(np.NaN, '03/31/2020')\n",
        "df['Cellulitis Date'] = df['Cellulitis Date'].replace(np.NaN, '03/31/2020')\n",
        "print(df['Ulcer Date'].head())\n",
        "print(df['Cellulitis Date'].head())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0    03/31/2020\n",
            "1    03/31/2020\n",
            "2    03/31/2020\n",
            "3    03/31/2020\n",
            "4    03/31/2020\n",
            "Name: Ulcer Date, dtype: object\n",
            "0    03/31/2020\n",
            "1    03/31/2020\n",
            "2    03/31/2020\n",
            "3     5/20/2019\n",
            "4    03/31/2020\n",
            "Name: Cellulitis Date, dtype: object\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZS1C734utvpz",
        "colab_type": "code",
        "outputId": "74351cdc-2cb1-41d5-ad25-9fdf599b1b01",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Determine current Data Frame shape\n",
        "print(df.shape)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(761, 13)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wN5JL8iJkz_5",
        "colab_type": "code",
        "outputId": "c58245ee-6318-4ddd-989d-b737f4f76890",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 141
        }
      },
      "source": [
        "# Convert 'DOB', \"Ulcer Date', and 'Cellulitis Date' columns to datetime64 after ensuring that they all have hyphens instead of lines.\n",
        "df[['DOB', 'Ulcer Date', 'Cellulitis Date']] = \\\n",
        "    df[['DOB', 'Ulcer Date', 'Cellulitis Date']].replace('/', '-', regex=True)  \n",
        "df[['DOB', 'Ulcer Date', 'Cellulitis Date']] = \\\n",
        "    pd.to_datetime(df[['DOB', 'Ulcer Date', 'Cellulitis Date']].stack(), format=\"%m-%d-%Y\", errors='coerce').unstack()\n",
        "# Ensure that the three columns are of type datetime64\n",
        "print(df[['DOB', 'Ulcer Date', 'Cellulitis Date']].dtypes)\n",
        "# Determine which of the 'DOB' column entries are not datetime64\n",
        "print(df[df['DOB'].isnull()])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "DOB                datetime64[ns]\n",
            "Ulcer Date         datetime64[ns]\n",
            "Cellulitis Date    datetime64[ns]\n",
            "dtype: object\n",
            "Empty DataFrame\n",
            "Columns: [BMI, DOB, Sex, NIDDM, IDDM, PVD, Neuro, Hyper, Ulcer, Cellulitis, Ulcer Date, Smoking, Cellulitis Date]\n",
            "Index: []\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a8ZfUHr0lyLJ",
        "colab_type": "code",
        "outputId": "c4bd4483-f0cf-4909-a575-d09b9d1e4b5d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 319
        }
      },
      "source": [
        "# Create new columns for age in years age achieved without an ulcer or cellulitis recorded. \n",
        "df['CellulitisAge'] = ((df['Cellulitis Date'] - (df['DOB'])) / timedelta(days=365))\n",
        "df['UlcerAge'] = ((df['Ulcer Date'] - (df['DOB'])) / timedelta(days=365))\n",
        "# Determine if there are any rows with Nan and eliminate them.\n",
        "print(df[df['CellulitisAge'].isnull()])\n",
        "print(df[df['UlcerAge'].isnull()])\n",
        "# Eliminate rows in 'UlcerAge' which do not have values.\n",
        "df = df.dropna(subset=['UlcerAge'])\n",
        "# Confirm shape of df.\n",
        "print(df.shape)\n",
        "# Change the data type of the new columns to int64 \n",
        "df['CellulitisAge'] = df['CellulitisAge'].astype('object').astype(np.int64)\n",
        "df['UlcerAge'] = df['UlcerAge'].astype('object').astype('int64')\n",
        "# The DOB, Cellulitis Date, and Ulcer Date columns are then dropped.\n",
        "df = df.drop(['DOB', 'Cellulitis Date', 'Ulcer Date'], axis=1)\n",
        "print(df.head())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Empty DataFrame\n",
            "Columns: [BMI, DOB, Sex, NIDDM, IDDM, PVD, Neuro, Hyper, Ulcer, Cellulitis, Ulcer Date, Smoking, Cellulitis Date, CellulitisAge, UlcerAge]\n",
            "Index: []\n",
            "      BMI        DOB  Sex  ...  Cellulitis Date CellulitisAge UlcerAge\n",
            "246  29.2 1938-01-11    0  ...       2020-03-31     82.273973      NaN\n",
            "476  37.6 1949-07-06    1  ...       2020-03-31     70.783562      NaN\n",
            "\n",
            "[2 rows x 15 columns]\n",
            "(759, 15)\n",
            "    BMI  Sex  NIDDM IDDM PVD  ... Ulcer Cellulitis  Smoking CellulitisAge UlcerAge\n",
            "0  28.2    0      1    0   1  ...     0          0        F            81       81\n",
            "1          0      0    1   0  ...     0          0        N            62       62\n",
            "2  40.7    1      1    0   0  ...     0          0        C            53       53\n",
            "3  38.4    0      0    1   0  ...     0          1        N            52       53\n",
            "4  29.8    1      1    0   1  ...     0          0        C            80       80\n",
            "\n",
            "[5 rows x 12 columns]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "onuC_hj9gnnw",
        "colab_type": "code",
        "outputId": "ea417d6a-c612-4274-ed2a-db62c436c8b5",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# Change the 'BMI' column from object to float64.\n",
        "df['BMI'] = pd.to_numeric(df['BMI'], errors='coerce')\n",
        "print(df['BMI'].dtypes)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I1dV7813Mq_9",
        "colab_type": "code",
        "outputId": "dafa46f9-46aa-4617-8444-28bb3a76d956",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 248
        }
      },
      "source": [
        "# The 'IDDM','PVD', 'Neuro', 'Hyper', and 'Cellulitis' columns are converted to int64.\n",
        "df['IDDM'] = df['IDDM'].astype('object').astype('int64')\n",
        "df['PVD'] = df['PVD'].astype('object').astype('int64')\n",
        "df['Neuro'] = df['Neuro'].astype('object').astype('int64')\n",
        "df['Hyper'] = df['Hyper'].astype('object').astype('int64')\n",
        "df['Cellulitis'] = df['Cellulitis'].astype('object').astype('int64')\n",
        "print(df.dtypes)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "BMI              float64\n",
            "Sex                int64\n",
            "NIDDM              int64\n",
            "IDDM               int64\n",
            "PVD                int64\n",
            "Neuro              int64\n",
            "Hyper              int64\n",
            "Ulcer              int64\n",
            "Cellulitis         int64\n",
            "Smoking           object\n",
            "CellulitisAge      int64\n",
            "UlcerAge           int64\n",
            "dtype: object\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FZ75lG-Fn_je",
        "colab_type": "code",
        "outputId": "50b93c5b-4a48-4124-bf05-79d26b021ccf",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 159
        }
      },
      "source": [
        "from sklearn.preprocessing import LabelEncoder\n",
        "from sklearn.preprocessing import OneHotEncoder\n",
        "\n",
        "# The 'Smoking' column is being changed from string to numerical\n",
        "le = LabelEncoder() \n",
        "df['Smoking']= le.fit_transform(df['Smoking'])\n",
        "print(df.head())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "    BMI  Sex  NIDDM  IDDM  ...  Cellulitis  Smoking  CellulitisAge  UlcerAge\n",
            "0  28.2    0      1     0  ...           0        2             81        81\n",
            "1   NaN    0      0     1  ...           0        3             62        62\n",
            "2  40.7    1      1     0  ...           0        0             53        53\n",
            "3  38.4    0      0     1  ...           1        3             52        53\n",
            "4  29.8    1      1     0  ...           0        0             80        80\n",
            "\n",
            "[5 rows x 12 columns]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1k0oZDZmmIGf",
        "colab_type": "code",
        "outputId": "e69749b2-fb9e-4613-95af-9820de8e99ff",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 159
        }
      },
      "source": [
        "# The 'Smoking' column is more than binary so one hot encoding must be done.\n",
        "du = pd.get_dummies(df['Smoking'], columns=['Smoking'], prefix='Smoke')\n",
        "df = pd.concat([df, du], axis=1)\n",
        "df = df.drop(['Smoking'], axis=1)\n",
        "print(df.head())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "    BMI  Sex  NIDDM  IDDM  PVD  ...  UlcerAge  Smoke_0  Smoke_1  Smoke_2  Smoke_3\n",
            "0  28.2    0      1     0    1  ...        81        0        0        1        0\n",
            "1   NaN    0      0     1    0  ...        62        0        0        0        1\n",
            "2  40.7    1      1     0    0  ...        53        1        0        0        0\n",
            "3  38.4    0      0     1    0  ...        53        0        0        0        1\n",
            "4  29.8    1      1     0    1  ...        80        1        0        0        0\n",
            "\n",
            "[5 rows x 15 columns]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4A-VdcSkbiDR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# # The 'Ulcer' column contains integers and strings that must ne changed to all integers.\n",
        "# print(df['Ulcer'].dtypes)\n",
        "# df['Ulcer'] = df['Ulcer'].astype(int)\n",
        "# print(df['Ulcer'].dtypes)\n",
        "# print(df['Ulcer'].unique())"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_Jrn6odoN1rr",
        "colab_type": "code",
        "outputId": "936e010a-b562-4a0d-c66a-5134f215b73e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 88
        }
      },
      "source": [
        "df.columns"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Index(['BMI', 'Sex', 'NIDDM', 'IDDM', 'PVD', 'Neuro', 'Hyper', 'Ulcer',\n",
              "       'Cellulitis', 'CellulitisAge', 'UlcerAge', 'Smoke_0', 'Smoke_1',\n",
              "       'Smoke_2', 'Smoke_3'],\n",
              "      dtype='object')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O1izO4kvm7GP",
        "colab_type": "code",
        "outputId": "6619ffd7-c413-4ac0-9b18-79b40010b085",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 124
        }
      },
      "source": [
        "# The missing BMI values for those with ulcers will be filled in with the mean of those having ulcers.\n",
        "# The missing BMI values for those without ulcers will be filled in with the mean of those not having ulcers.\n",
        "mean0, mean1 = df.groupby('Ulcer').mean()['BMI'].values\n",
        "for i, row in df.iterrows():\n",
        "  if row['Ulcer'] == 0 and np.isnan(row['BMI']):\n",
        "    df.loc[i, 'BMI'] = mean0\n",
        "  elif row['Ulcer'] == 1 and np.isnan(row['BMI']):\n",
        "    df.loc[i, 'BMI'] = mean1\n",
        "print(df['BMI'].head())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0    28.200000\n",
            "1    33.942791\n",
            "2    40.700000\n",
            "3    38.400000\n",
            "4    29.800000\n",
            "Name: BMI, dtype: float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4srBipKC9Kcr",
        "colab_type": "code",
        "outputId": "d7094258-41fd-4ec2-c0a6-23c9343b36d0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 294
        }
      },
      "source": [
        "# Create a histogram of the 'BMI', 'UlcerAge', and CellulitisAge columns.\n",
        "df[['BMI', 'UlcerAge', 'CellulitisAge']].hist()\n",
        "plt.suptitle('Histogram of three columns.')\n",
        "plt.show()\n",
        "# It is interesting to note that the CellulitisAge and UlcerAge features both peak at approximately age 60.\n",
        "# The BMI peaks at approximately 30. "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 4 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5qv9nH1fs6Vm",
        "colab_type": "code",
        "outputId": "b7309c17-b085-412a-d6c9-95bf46876d31",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 585
        }
      },
      "source": [
        "# Create a pairplot of the 'BMI', 'UlcerAge', and CellulitisAge columns.\n",
        "plt.figure(figsize=(12, 6))\n",
        "sns.pairplot(df[['BMI', 'UlcerAge', 'CellulitisAge']])\n",
        "plt.suptitle('Pairplot of Three Columns')\n",
        "plt.show()\n",
        "# The pairplot confirms the linear relationship between UlcerAge and CellulitisAge and the non-liear relationship\n",
        "# between those two and the BMI."
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 864x432 with 0 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 540x540 with 12 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zEjmdapv742T",
        "colab_type": "code",
        "outputId": "8bf79e13-3191-4f30-b22b-b57b28ed7e80",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 442
        }
      },
      "source": [
        "# Create a boxplot of the columns. In the next cell, the boxplot of 'UlcerAge' will be examined.\n",
        "plt.figure(figsize=(12, 6))\n",
        "df.boxplot()\n",
        "plt.title('Comparison of Column Boxplots')\n",
        "plt.xticks(rotation=90)\n",
        "plt.show()"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsUAAAGpCAYAAABlFUukAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzde5hddXn3//edBAISDgE0CiLEqpj8OGiDipoqAY9FwQMqUSrUFERqxEI1aGxR+8SKFiulCkiD4FNIFKpyKhSFiRh9oIIoASIeOIigoBgOiQRIcv/+WGvCzmRmMjOZvddas9+v65prZq+19tqf2dmZfe/v+h4iM5EkSZK62biqA0iSJElVsyiWJElS17MoliRJUtezKJYkSVLXsyiWJElS17MoliRJUtezKJbUlSLiPRFxVdU5ekXE1hFxaUQ8HBEXtuH8d0XEa0b7vE0REUsi4m+qziGpviyKJW2WiHh3RNwQESsj4rcRcUVEzKw616Zk5vmZ+bqqc7Q4DJgC7JSZ7+jvgIh4QURcGBF/KIvnmyPihIgY39moIxcR50bEE+Xr5dGIuDEiXl11rl4RsUdEZERMqDqLpM6yKJY0YhFxAvBF4DMUBd1zgC8Dh1aZa1NqWvDsDvw8M9f0tzMi/gy4HrgH2DsztwfeAewHbNuxlKPjc5k5CdgOOAP4ZpMKe0ljk0WxpBGJiO2BTwN/m5nfzMxVmflkZl6amR8pj5kYEV+MiPvKry9GxMRy3wER8ZuI+GhEPFC2Mr8lIv4yIn4eEX+MiI+3PN4nI+KiiPh62cL444jYt2X/SRHxq3LfbRHx1pZ9R0XEDyLiXyPiQeCT5bal5f4o9z0QEY9ExLKI2Kv394yIr0XE7yPi7oj4RESMaznv0oj4l4hYERF3RsQbB3nOppWX8R+KiFsj4pBy+6eAfwTeVbagzunn7p8CfpiZJ2TmbwEy8/bMfHdmPlSe55DyvA+VjzNtgBznRsT/abl9QET8puX2XRHxkbIlelVELIyIKeVVgEcj4rsRMbk8trdl9ciI+HXZij1/oOegVRZLql4A7EjxoYqIGFc+x3eX/x5fK19rRMR/R8SpLTkXR8Q55c+9/8b/Xrai/ywiDhrg9x/wMYBry+8Plf8WL4+I50XE98rz/iEivj6U309Ss1gUSxqplwNbAd8a5Jj5wP7Ai4B9gZcCn2jZ/8zyHLtSFIVnA0cAM4C/AP4hIqa2HH8ocCFFEXUB8O2I2KLc96vyPttTFJD/GRHParnvy4A7KIqvBX1yvg54FfCC8v7vBB4s951ebnsu8GrgvcBf9znv7cDOwOeAhRERfZ+IMuelwFXAM4C5wPkRsWdmnkzR2v71zJyUmQv73h94DXBRP9t7z/8CYBHwYeDpwH8Dl0bElgPdZxPeDryW4jl5M3AF8PHy3OOAD/U5fiawJ3AQ8I8DFeR9Mo+neD7vBO4vNx9Vfs2ieM4nAf9e7nsf8FcRcWBEvIfi9XR8yylfRvE62Bk4maIFesd+Hnqwx3hV+X2H8t/i/wH/RPHvNhl4NsVrQtIYY1EsaaR2Av4w0OX+0nuAT2fmA5n5e4pi9a9a9j8JLMjMJ4HFFMXMaZn5aGbeCtxGUUz3ujEzLyqP/wJFQb0/QGZemJn3Zea6zPw68AuKoqnXfZl5emauyczH+uR8kqILwguByMzlmfnbsmg7HPhYmeku4NQ+v8PdmXl2Zq4FzgOeRdnq2cf+FMXXZzPzicy8BrgMmD3I89dqJ+C3g+x/F3B5Zn6nfH7+BdgaeMUQz9/X6Zl5f2beC3wfuD4zb8rM1RQfhF7c5/hPZeZjmflT4Kds+O/W199HxEPASoruN/9QPn9QvGa+kJl3ZOZK4GPA4RExITN/B3yA4nk+DXhvZj7act4HgC+WVyy+TvFh5eB+Hn/Axxgg75MU3Vt2yczVmbl0kN9NUkNZFEsaqQeBnQcpJAB2Ae5uuX13uW39OVqKod5C9f6W/Y9RFJK97un9ITPXAb/pPV9EvDciflJ2HXgI2IuiyN7ovn2VBeq/A18CHoiIr0TEduX9t+jnd9i15fbvWs7zp/LH1sy9dgHuKXMPdK7BPEhRcA9kg+e6fJx7hnH+vvr+Owz27wItzwPwp372t/qXzNwBeBpFn+jPt3Q76e81M4GnPmhcCowHbu+nOL237JLRet9d2NimHqOvjwIB/G/ZPeV9g/xukhrKoljSSP0/4HHgLYMccx9FC1uv55TbRmq33h/Kfr3PBu6LiN0pul58kGL2hh2AWygKmV6txdJGMvPfMnMGMJ2iy8BHgD/wVCth6+9w7wiy3wfs1tsfeQTn+i5Fl4bBzr8+Z9mFY7cBzr+KoiDt9cwhZhhVWbgF+AFPtej295pZw1NF+QJgOfCsiOjbyr5rn64rA73eBnuMjV4nmfm7zDw6M3cB3g98OSKeN4RfUVKDWBRLGpHMfJiiH/CXohgg97SI2CIi3hgRnysPWwR8IiKeHhE7l8f/52Y87IyIeFvZOv1hiqL8OmAbimLm9wAR8dcULcVDEhEviYiXlf1+VwGrgXVlK/Y3gAURsW1ZfJ8wwt/heooW1I+Wz9MBFH11Fw/x/icDr4iIz0fEM8vcz4uI/4yIHcqcB0fEQeXvcSLF8/PDfs71E+AvI2LH8lwfHsHvMyoi4oUU/ZFvLTctAv4uIqZGxCSe6mu9JiJeRdGf+73AkcDpEdHaEv4M4EPl8/sOYBpF3+q+BnwMitfQOoq+xr0Z3xERzy5vrqB4ra1D0phiUSxpxDLzVIoi8RMUxcQ9FK213y4P+T/ADcDNwDLgx+W2kbqYou/sCop+vW8r+4/eRtHX9/9RtPbtTdH6OFTbUbQ0r6C4lP4g8Ply31yKQvkOYCnFAL9zhhs8M5+gKILfSNEC/WWKPrE/G+L9f0UxuHEP4NaIeBj4L4rn99HMvJ1ikOLp5fnfDLy5fNy+/i9Fv9+7KAaQdXo2hY+WMzusKh//q8BZ5b5zynzXUgzAWw3MLbuzfA34YGbem5nfBxYCX21pHb4eeD7F778AOCwzewdMtur3MWB9F5gFwA/Krjj7Ay8Bro+IlcAlwPGZecfoPR2S6iA27H4lSfUUEZ8EnpeZR1SdRfUTEUcBf5OZtV84RlI92VIsSZKkrmdRLEmSpK5n9wlJkiR1PVuKJUmS1PUGm3S/Y3beeefcY489Rv28q1atYpttthn187aTmduvaXnBzJ3QtLxg5k5oWl5oXuam5QUzd0I78954441/yMynb7QjMyv/mjFjRrZDT09PW87bTmZuv6blzTRzJzQtb6aZO6FpeTObl7lpeTPN3AntzAvckP3Uo3afkCRJUtezKJYkSVLXsyiWJElS17MoliRJUtezKJYkSVLXsyiWJElS17MoliRJUtezKJYkSVLXsyiWJElS17MoliRJUtezKJYkSVLXsyiWJElS17MoliRJUtebsKkDIuIc4E3AA5m5V7ltR+DrwB7AXcA7M3NFRARwGvCXwJ+AozLzx+2JLknS6CnewoYuM9uUZGiallequ6G0FJ8LvKHPtpOAqzPz+cDV5W2ANwLPL7+OAc4YnZiSJLVXZm70tfu8y/rdXocCc6BcA2WWNLhNFsWZeS3wxz6bDwXOK38+D3hLy/avZeE6YIeIeNZohZUkSZLaIYby6TEi9gAua+k+8VBm7lD+HMCKzNwhIi4DPpuZS8t9VwPzMvOGfs55DEVrMlOmTJmxePHi0fmNWqxcuZJJkyaN+nnbyczt17S8YOZOaFpeMHMnHHXlKs59wzZVxxiWpmVu2msCzNwJ7cw7a9asGzNzv77bN9mneFMyMyNi2NdlMvMrwFcA9ttvvzzggAM2N8pGlixZQjvO205mbr+m5QUzd0LT8oKZO+LKy5uVFxqXuXGvCczcCVXkHensE/f3dosovz9Qbr8X2K3luGeX2yRJkqTaGmlRfAlwZPnzkcDFLdvfG4X9gYcz87ebmVGSJElqq6FMybYIOADYOSJ+A5wMfBb4RkTMAe4G3lke/t8U07H9kmJKtr9uQ2ZJkiRpVG2yKM7M2QPsOqifYxP4280NJUmSJHWSK9pJkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqettVlEcEX8XEbdGxC0RsSgitoqIqRFxfUT8MiK+HhFbjlZYSZIkqR1GXBRHxK7Ah4D9MnMvYDxwOHAK8K+Z+TxgBTBnNIJKkiRJ7bK53ScmAFtHxATgacBvgQOBi8r95wFv2czHkCRJktoqMnPkd444HlgAPAZcBRwPXFe2EhMRuwFXlC3Jfe97DHAMwJQpU2YsXrx4xDkGsnLlSiZNmjTq520nM7df0/KCmTuhaXnBzJ1w1JWrOPcN21QdY1ialrlprwkwcye0M++sWbNuzMz9NtqRmSP6AiYD1wBPB7YAvg0cAfyy5ZjdgFs2da4ZM2ZkO/T09LTlvO1k5vZrWt5MM3dC0/JmmrkTdp93WdURhq1pmZv2msg0cye0My9wQ/ZTj25O94nXAHdm5u8z80ngm8ArgR3K7hQAzwbu3YzHkCRJktpuc4riXwP7R8TTIiKAg4DbgB7gsPKYI4GLNy+iJEmS1F4jLooz83qKAXU/BpaV5/oKMA84ISJ+CewELByFnJIkSVLbTNj0IQPLzJOBk/tsvgN46eacV5IkSeqkzSqKJUlqmn0/dRUPP/bkkI/f46TLh3Tc9ltvwU9Pft1IY0mqmEWxJKmrPPzYk9z12YOHdOySJUs44IADhnTsUItnSfW0uYt3SJIkSY1nS7EkSTVnlw+p/SyKJUmqObt8SO1n9wlJkiR1PYtiSZIkdT2LYkmSJHU9i2JJkiR1vTFZFC9atIi99tqLgw46iL322otFixZVHUmSJEk1NuZmn1i0aBHz589n4cKFrF27lvHjxzNnzhwAZs+eXXE6SZIk1dGYaylesGABCxcuZNasWUyYMIFZs2axcOFCFixYUHU0SZIk1dSYK4qXL1/OzJkzN9g2c+ZMli9fXlEiSZIk1d2YK4qnTZvG0qVLN9i2dOlSpk2bVlEiSZIk1d2YK4rnz5/PnDlz6OnpYc2aNfT09DBnzhzmz59fdTRJkiTV1JgbaNc7mG7u3LksX76cadOmsWDBAgfZSZIkaUBjriiGojCePXv2sNZ/lyRJUvcac90nJEmSpOGyKJYkSVLXsyiWJElS17MoliRJUtezKJYkSVLXsyiWJElS17MoliRJUtezKJYkSVLXsyiWJElS1xuTK9pJkjSQbaedxN7nnTT0O5w31PMCHDySSJJqwKJYktRVHl3+We767NCK1yVLlnDAAQcM6dg9Trp8M1JJqprdJyRJktT1bCmWJKnm7PIhtZ9FsSRJNWeXD6n97D4hSZKkrmdRLEmSpK5nUSxJkqSuZ1EsSZKkrmdRLEmSpK5nUSxJkqSuZ1EsSZKkrmdRLEmSpK5nUSxJkqSuZ1EsSZKkrmdRLEmSpK5nUSxJkqSuZ1EsSZKkrmdRLEmSpK5nUSxJkqSuZ1EsSZKkrmdRLEmSpK5nUSxJkqSut1lFcUTsEBEXRcTPImJ5RLw8InaMiO9ExC/K75NHK6wkSZLUDpvbUnwacGVmvhDYF1gOnARcnZnPB64ub0uSJEm1NeKiOCK2B14FLATIzCcy8yHgUOC88rDzgLdsbkhJkiSpnTanpXgq8HvgqxFxU0T8R0RsA0zJzN+Wx/wOmLK5ISVJkqR2iswc2R0j9gOuA16ZmddHxGnAI8DczNyh5bgVmblRv+KIOAY4BmDKlCkzFi9ePKIc/TnttNO4/PLLefLJJ9liiy04+OCDOf7440ft/O20cuVKJk2aVHWMYWla5qblBTN3QtPygplH6qgrV3HuG7YZ0rHDyTuc8w5XEzMPVR1eE8Nl5vZrZ95Zs2bdmJn7bbQjM0f0BTwTuKvl9l8AlwO3A88qtz0LuH1T55oxY0aOlg9+8IM5YcKEPPXUU/OKK67IU089NSdMmJAf/OAHR+0x2qmnp6fqCMPWtMxNy5tp5k5oWt5MM4/U7vMuG/Kxw8k7nPMOVxMzD1UdXhPDZeb2a2de4Ibspx4dcfeJzPwdcE9E7FluOgi4DbgEOLLcdiRw8UgfYyTOPvtsTjnlFE444QS22morTjjhBE455RTOPvvsTsaQJElSg0zYzPvPBc6PiC2BO4C/puin/I2ImAPcDbxzMx9jWB5//HGOPfbYDbYde+yxnHjiiZ2MIUmqsT1OunzoB185tGO333qLEaYZmiZmlppks4rizPwJsHGfjKLVuBITJ07kmGOO4Sc/+QnLly9n2rRpvOhFL2LixIlVRZIk1chdnz14yMfucdLlwzq+XZqYWWqaMbei3atf/WrOP/98XvWqV3HxxRfzqle9ivPPP59Xv/rVVUeTJElSTW1u94nauffee9lvv/0488wzOeOMM4gI9ttvP+69996qo0mSJKmmxlxRfNttt7HHHntw9dVXs3btWsaPH8+cOXO46667qo4mSZKkmhpzRfGWW27JK17xCubOnbu+T/ErXvEK7rvvvqqjSZIkqabGXFH8xBNPsHjxYj73uc8xffp0brvtNj760Y+ybt26qqNJkiSppsZcUbzlllty2GGHcc4556xvKT788MO56KKLqo4mSZKkmhpzRfETTzzBD3/4QxYuXLhBn+Innnii6miSJEmqqTFXFE+fPp0//elPHHjggeu3TZ06lenTp1eYSpIkSXU25uYpHjduHHfeeSfbbrst48aNY9ttt+XOO+9k3Lgx96tKkiRplIy5SnHZsmVstdVW7LTTTmQmO+20E1tttRXLli2rOpokSZJqaswVxQDHHXcc22yzDRHBNttsw3HHHVd1JEmSJNXYmOtTDHDWWWdx6aWXrh9o9+Y3v7nqSJIkSaqxMddSHBGsWrWKCy+8kNWrV3PhhReyatUqIqLqaJIkSaqpMdlSvPXWW3PGGWdwxhlnrL+9evXqilNJkiSprsZcS/H06dN5/etfz8SJEwGYOHEir3/9652STZIkSQMacy3Fs2bN4swzz+SUU05Zv8zzvHnzOPbYY6uOJkmSpJoac0VxT08P8+bN22CZ53nz5vHtb3+76miSJEmqqTHXfWL58uXsueeeG2zbc889Wb58eUWJJEmSVHdjrqV4l1124aMf/SgXXHDB+inZ3v3ud7PLLrtUHU2SJEk1NeaKYoA//vGPHHjggetvb7nlljzjGc+oMJEkSZLqbMwVxb/5zW8AGDduHOvWrWPcuHE88cQT67dLkiRJfY25PsXwVEEMrC+MJUmSpIGMyWqxtyAe6LYkSZLUakwWxQDbbrst48aNY9ttt606iiRJkmpuzBbFEyZMYN26dUyYMOa6TUuSJGmUjdmieMWKFRt8lyRJkgYyZovirbfemohg6623rjqKJEmSam7M9i147LHHNvguSZIkDWTMthRLkiRJQzVmi+LeuYmdo1iSJEmbMmYrxszc4LskSZI0kDFZFI8fP36Donj8+PEVJ5IkSVKdjcmieO3atUyZMoWIYMqUKaxdu7bqSJIkSaqxMTv7xP3337/Bd0mSJGkgY7KlWJIkSRoOi2JJkiR1PYtiSZIkdb0xWxRHxAbfJUmSpIGM2aLYeYolSZI0VGO2KLalWJIkSUM1ZotiW4olSZI0VGNmnuKhtAi3HmOxLEmSpF5jpijuLXK32GILANasWbN+34QJxa/55JNPdj6YJEmSam/MdZ849thjWbduHVOmTAGKZZ7XrVvHscceW3U0SZIk1dSYaSnudfrppwNw9tlnA8lDDz3Ecccdt367JEmS1NeYaymGojBevXo1u8+7jNWrV1sQS5IkaVBjsiiWJEmShsOiWJIkSV3PoliSJEldz6JYkiRJXW+zi+KIGB8RN0XEZeXtqRFxfUT8MiK+HhFbbn5MSZIkqX1Go6X4eGB5y+1TgH/NzOcBK4A5o/AYkiRJUttsVlEcEc8GDgb+o7wdwIHAReUh5wFv2ZzHkCRJktotepdHHtGdIy4C/hnYFvh74CjgurKVmIjYDbgiM/fq577HAMcATJkyZcbixYtHnGMgR125inPfsM2on7edVq5cyaRJk6qOMSxNy9y0vGDmTmhaXjBzJzTxfaRpmZv2mgAzd0I7886aNevGzNxvox2ZOaIv4E3Al8ufDwAuA3YGftlyzG7ALZs614wZM7Iddp93WVvO2049PT1VRxi2pmVuWt5MM3dC0/JmmrkTmvg+0rTMTXtNZJq5E9qZF7gh+6lHN2eZ51cCh0TEXwJbAdsBpwE7RMSEzFwDPBu4dzMeQ5IkSWq7EfcpzsyPZeazM3MP4HDgmsx8D9ADHFYediRw8WanlCRJktqoHfMUzwNOiIhfAjsBC9vwGJIkSdKo2ZzuE+tl5hJgSfnzHcBLR+O8kiRJUie4op0kSZK6nkWxJEmSup5FsSRJkrqeRbEkSZK6nkWxJEmSup5FsSRJkrqeRbEkSZK63qjMU9xJ+37qKh5+7MkhH7/HSZcP+djtt96Cn578upHEkiRJUoM1rih++LEnueuzBw/p2CVLlnDAAQcM+dzDKaAlSZI0dth9QpIkSV3PoliSJEldz6JYkiRJXa9xfYq3nXYSe5930tDvcN5wzg0wtP7KkiRJGjsaVxQ/uvyzDrSTJEnSqLL7hCRJkrqeRbEkSZK6nkWxJEmSup5FsSRJkrpe4wbaSZIkiIiB952y8bbMbGMaqflsKZYkqYEyc/3XBRdcwNSpU7nmmmv4zne+wzXXXMPUqVO54IIL1h8jaXAWxZIkNdyCBQtYuHAhs2bNYsKECcyaNYuFCxeyYMGCqqNJjWH3CUmSGLg7Qn9dEaBe3RGWL1/OzJkzN9g2c+ZMli9fXlEiqXlsKZYkiQ27I/R+9fT09Lu9TgUxwLRp01i6dOkG25YuXcq0adMqSiQ1TyNbioe18tyVQz92+623GEEaSZKqNX/+fObMmcPChQtZu3YtPT09zJkzx+4T0jA0rige6hLPUBTPwzlekiSAuXPncvbZZ/P4448zceJEjj76aE4//fSqYw1o9uzZzJs3jwMPPHD9tt12243Zs2dXmEpqFrtPSJLUYu7cuZx55pl85jOf4YorruAzn/kMZ555JnPnzq062oD22Wcf7rnnHg455BC+9a1vccghh3DPPfewzz77VB1NagyLYkmSWpx99tmccsopnHDCCWy11VaccMIJnHLKKZx99tlVRxvQsmXLOOSQQ7j44ovZYYcduPjiiznkkENYtmxZ1dGkxrAoliSpxeOPP87kyZPZa6+9OOigg9hrr72YPHkyjz/+eNXRBrVw4cJBb0saXOP6FEuS1E4TJkzg7//+77noootYu3Yt48eP57DDDmPChHq/Zc6ZM4eLL754g9uShs6WYkmSWmy33XY8/PDD3HTTTaxZs4abbrqJhx9+mO22267qaAPae++9ueSSSzj00EN56KGHOPTQQ7nkkkvYe++9q44mNUa9P/ZKktRhDz30EO9///v5+Mc/vn72iWOOOYazzjqr6mgDuvnmm9lnn3245JJLuOSSS4CiUL755psrTiY1hy3FkiS1mDZtGu94xztYvXo1PT09rF69mne84x21Xwjj5ptv3mDBEQtiaXgsiiVJatG7EEZPTw9r1qxZvxDG/Pnzq44mqY3sPiFJUoveBS/mzp3L8uXLmTZtGgsWLHAhDGmMsyiWJKmP2bNnM3v2bJYsWcIBBxxQdRxJHWD3CUmS+li0aNEG8xQvWrSo6kiS2syWYkmSWixatIj58+ezcOHC9fMU9875axcKaeyypViSpBYLFixg4cKFzJo1iwkTJjBr1iwWLlzIggULqo4mqY0siiVJarF8+XJmzpy5wbaZM2eyfPnyihJJ6gSLYkmSWkybNo2lS5dusG3p0qW1n6dY0uaxKJYkqYXzFEvdyYF2kiS1aOo8xYsWLWLBggXrM8+fP7/2maU6sSiWJKmPps1T7IwZ0uaz+4QkSQ3njBnS5rMoliSp4ZwxQ9p8FsWSJDWcM2ZIm29MFsX77LMPEcHdp7yJiGCfffapOpIkSW3jjBnS5hszA+0iYsB9y5Yt22h/ZrY7kiSpoZo2k0NTZ8yQ6mTMFMW9RW5EMG7cONatW7d+X+9tC2FJ0qY0dSaHps2YIdXNmOw+sW7dOj7wgQ9w6aWX8oEPfGCDAlmSpME4k4PUnUZcFEfEbhHRExG3RcStEXF8uX3HiPhORPyi/D559OIOzU477cS1117LoYceyrXXXstOO+3U6QiSpIZyJgepO21OS/Ea4MTMnA7sD/xtREwHTgKuzsznA1eXtzvqwQcf5I477iAzueOOO3jwwQc7HUGS1FDO5CB1pxEXxZn528z8cfnzo8ByYFfgUOC88rDzgLdsbsiReOyxx8hMHnvssSoeXpLUUM7kIHWnGI3BZxGxB3AtsBfw68zcodwewIre233ucwxwDMCUKVNmLF68eLNzAMyaNWvAfT09PaPyGO20cuVKJk2aVHWMYWla5qblBTN3QtPygpnb6bTTTuPyyy/nySefZIsttuDggw/m+OOPrzrWoK6++mr+8z//k1//+tc85znP4YgjjuCggw6qOtYmNeU10crM7dfOvLNmzboxM/fbaEdmbtYXMAm4EXhbefuhPvtXbOocM2bMyNECDPjVBD09PVVHGLamZW5a3kwzd0LT8maauV0uuBxj0ZEAAB7SSURBVOCCnDp1al5zzTX5ne98J6+55pqcOnVqXnDBBVVHG1ATM/dqwmuiLzO3XzvzAjdkP/XoZs0+ERFbAP8FnJ+Z3yw33x8Rzyr3Pwt4YHMeY4S5OPXUU7niiis49dRTB53DWJKkVk2cfaKJmaW6GfE8xWXXiIXA8sz8QsuuS4Ajgc+W3y/erIQjsNVWW3HSSSetv+y11VZb2bdYkjQkTZx9oomZpbrZnJbiVwJ/BRwYET8pv/6Sohh+bUT8AnhNebujIoJdd92VcePGseuuu9pSLEkasibOPtHEzFLdjLilODOXAgNVm5X17B8/fjyrV69m7ty5TJ8+ndtuu42PfOQjjB8/vqpIkqQG6Z19ondFu97ZJ+rcFaGJmaW6GTPLPPdat24dEyZM4MQTT1y/bYsttmDNmjUVppIkNUXvUs5z585l+fLlTJs2jQULFtR+iWdoVmapbsZcUTx58mRWrFjBM5/5TB544AGe8YxncP/99zN5cscX1pMkNdTs2bOZPXs2S5Ys4YADDqg6zpA0MbNUJ2OuKH7kkUfYYYcduOCCC1i7di3jx4/n7W9/O4888kjV0SRJklRTY64oXrNmDaeeeuoGl5BOPfVU3ve+91UdTZIkSTW1WfMU19HEiRNZsWIFt9xyC1dffTW33HILK1asYOLEiVVHkyRJUk2NuZbio48+mnnz5gEwffp0vvCFLzBv3jyOPfbYipNJkiSprsZcUXz66acD8PGPf5zHH3+ciRMncuyxx67fLkmSJPU15rpPQFEYr169mp6eHlavXm1BLEmSpEGNyaJYkiRJGg6LYkmSJHU9i2JJkiR1PYtiSZIkdT2LYkmSJHU9i2JJkiR1PYtiSZIkdT2LYkmSJHU9i2JJkiR1PYtiSZIkdT2LYkmSJHU9i2JJkiR1PYtiSZIkdT2LYkmSJHU9i2JJkiR1PYtiSZIkdT2LYkmSJHU9i2JJkiR1PYtiSZIkdT2LYkmSJHU9i2JJkiR1PYtiSZIkdT2LYkmSJHU9i2JJkiR1PYtiSZIkdT2LYkmSJHU9i2JJkiR1PYtiSZIkdT2LYkmSJHU9i2JJkiR1PYtiSZIkdT2LYkmSJHU9i2JJkiR1PYtiSZIkdT2LYkmSJHU9i2JJkiR1PYtiSZIkdT2LYkmSJHU9i2JJkiR1vQlVB5AkDU9EbLQtMytIMnRNzKz2auJroomZNXS2FEtSg/T3pjzY9jpozTZ58uR+t6u7NP11fMQRR/S7Xc1mUSxJDZSZ9PT0NKqVKjP55je/2ajMaq+mvo7nzJnTqMwamrZ0n4iINwCnAeOB/8jMz7bjcZpi7/P2Ht4dzhv6ocuOXDa8cw9R0zLv+6mrePixJzfafvcpbxrWeXafd9kGt7ffegt+evLrNivbQPrLPNy80LnM7XqOoXmZ2/m6GKt23333jW7ffffdFaWRRuaTn/zkRrf7buuk0XgfGQt/k2GUMmfmqH5RFMK/Ap4LbAn8FJg+2H1mzJiR7dDT09OW8w7X7vMuG/Kxw8k8nPMOV9MyNy3vcM9dh8zDPW/TMtch71AAWfzpfipz67Y6amLmXnV5HxmOJmRu4muijpmb9jeuXXmHe27ghuynHm1HS/FLgV9m5h0AEbEYOBS4rQ2PJUldqYn9GCOCyZMns2LFiqqjqCaa+jo+4ogjmDVrVtVRNMoiR7lPTEQcBrwhM/+mvP1XwMsy84N9jjsGOAZgypQpMxYvXjyqOQBWrlzJpEmTRv28w3XUlas22jYal8m32QK+dNA2I841mNHI3N/ljXZlnnv33FE/Z6/Tdz+9LedtWuZ25oXmZfZ1UWji62I46vI+Mhx1yNzE10XT/u9B8zLX5XUxa9asGzNzv4129Nd8vDlfwGEU/Yh7b/8V8O+D3Wesd58YDjO3X9PyZpq5E5qWN9PMndC0vJnNy9y0vJlm7oR25mWA7hPtmH3iXmC3ltvPLrdJkiRJtdSOovhHwPMjYmpEbAkcDlzShseRJEmSRsWoD7TLzDUR8UHgfyhmojgnM28d7ceRJEmSRktb5inOzP8G/rsd55YkSZJGmyvaSZIkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp61kUS5IkqetZFEuSJKnrWRRLkiSp60VmVp2BiPg9cHcbTr0z8Ic2nLedzNx+TcsLZu6EpuUFM3dC0/JC8zI3LS+YuRPamXf3zHx63421KIrbJSJuyMz9qs4xHGZuv6blBTN3QtPygpk7oWl5oXmZm5YXzNwJVeS1+4QkSZK6nkWxJEmSut5YL4q/UnWAETBz+zUtL5i5E5qWF8zcCU3LC83L3LS8YOZO6HjeMd2nWJIkSRqKsd5SLEmSJG2SRbEkSZK6nkWxJEmSup5FcQ1ExJw+t8dHxMlV5RlLImLHwb6qzjcWRcSUiHhT+fWMqvMMpPx/1lN1juEoM/+s6hzDERHbRMS48ucXRMQhEbFF1bkkqa8JVQcYLRFxwmD7M/MLncoyAgdFxNuBOcCOwLnA9ypNNICI+LfB9mfmhzqVZYj+APwGWFPejpZ9CTy344mGICKOBI4H9iw3LQf+LTO/Vl2qTYuIdwKfB5ZQPNenR8RHMvOiSoP1IzPXRsS6iNg+Mx+uOs9QlJlvj4jnZOavq84zRNcCfxERk4GrgB8B7wLeU2mqQUTE04ATgedk5tER8Xxgz8y8rOJoA4qIKcBngF0y840RMR14eWYurDjaRiJie+BjwFuAZ1D8LX4AuBj4bGY+VGG8YYmIKzLzjVXn6CsitqN4jp8NXJGZF7Ts+3JmHldZuH5ExDOBk4F1wD8Cc4G3U7z3HZ+Zv+1EjjFTFAPbVh1gpDLz3RHxLmAZsAp4d2b+oOJYAzkWuAX4BnAfGxaZdfRvwCzgB8AiYGnWfMqVsiD+MHAC8GOK5/jPgc9HRGbm/60y3ybMB16SmQ8ARMTTge8CtSuKSyuBZRHxHYr/e0AtP9y1mgzcGhH/y4aZD6ku0qAiM/9UXhH7cmZ+LiJ+UnWoTfgqcCPw8vL2vcCFQG2LYorGlK9S/B8E+DnwdaB2RTHF+8c1wAGZ+TtYXxQdWe57XYXZNhIRfz7QLuBFncwyDF8FfgH8F/C+suHt3Zn5OLB/pcn6dy5wObAN0AOcD/wlxQenM4FDOxHCKdlqoGyFOI+iKJ4G3AackJl/qjRYPyJiJ+AdFC09ayj+6F5U50/2ERHAAcBs4KUUrVVnZOadVeYaSERcBxyemXf12b4HsDgz6/gHDYCIWJaZe7fcHgf8tHVbnZQfQDaSmed1OstQRcSr+9uemXW9unQTcBzwr8CczLy17+ukbnqXl42ImzLzxeW2n2bmvlVnG0hE/CgzX9In808ys3ZFW0Tcnpl7DndfVSJiLcXV2/4agfbPzK07HGmT+v7bR8R8iiLzEOA7mTlQoV+JPq/bX2fmc1r2dex1PGZaiht4Wb/VpcAHM/O7ZQF3AsUlxv+v2lgby8wHKT61nRkRzwYOB26LiHl1bcEsW4Z7yjfnw4F/ovgEfXalwQa2Xd+CGCAz7yovidXZlRHxPxSt8lB8ePrvCvMMKjPPi4itKS6T3151nqHIzO9FxO7A88u/GU8DxledaxAfpriM+62yIH4uRUtQnT1Rvi4SICL+DHi82kibtKpstOjNvD9Q125Bd0fER4HzMvN+WN/94yjgniqDDWA58P7M/EXfHRFRx7wAEyNiXGauA8jMBRFxL0V3pknVRutX6xi3vt0EOzb+bcwUxTTvsn6rl2bmI7C+gDs1Ii6tONOgystJs4HXAldQXGqsnYjYhuKyy7uApwPfBGbUvD/mYyPcV6nyA92/AS8BZpabv5KZ36ou1eAi4s3AvwBbAlMj4kXAp2vcFYGIOBo4hmL8wZ8Bu1J8UD2oylwDKVuwv9dy+w6gzo0UUPRtvBLYLSLOB15JUbDV2QnAJcCfRcQPKP7eHVZtpAG9CzgJ+F7LYNz7KfK/s7JUA/skAxdmczuYYzguBQ6k6L4GQGaeGxG/A06vLNXALo6ISZm5MjM/0bsxIp5H0RWoI8ZM94kmXtbv1TJAYtfMfEPNB0h8GjiY4pPzYuDKzFwz+L2qExGrKFqFF5ffN3jBZ+Y3q8g1mIj4E/DL/nYBz83MbTocacjqflm8r4i4keKNY0nLpbtbMnOvapMNrOyP+1Lg+pbMtXveI+KLmfnh8gP+Rm80df7gAevfU/an+H93XWb+oeJImxQREygG5wZwe2Y+WXGkzRIRR9a5K1NfTcsLzcvc7rxjpihu1XJZ/wSgtpf1e0XEFZQDJDJz3/IP2011e5MDiIh1wJ1Ab3/n3hdQUDR071NJsAFExLn084Zcysx8XwfjDEl5aXxAmXl3p7IMV0ScB/x7Zv6o6ixDERHXZeb+ffqz3Vy313GriLg+M1/Wm7n8e/HjumWOiBmZeWPT+kDDgAOrHgburmsjQES8rZ/NDwPLege+Nk1E/LhufV8H07S80LzM7c47lrpPAM25rN/Hzpn5jYj4GEBmrik79tfR1KoDDEdmHlV1hhH4KHBBjWcgGczLgPdExN0UMyPU8sNSi1sj4t3A+HLA64eAH1acaVO+FxEfB7aOiNdSDGKrXXerzOz92/uizDytdV9EHE9Np50sfZlixpebKV7DewG3AttHxAcy86oqww1gDsVsGb39tQ+geP+bGhGfrnvj0ACa1A0SmpcXmpe5rXnHTFHcz2X9j9X1E30/GjNAoreVMiJ2AJ5fbv551nie14jYk6IP5gvLTcsp+rp2rJ/SMP0c+JeIeBZFH/lFmXlTxZmG6vVVBximuRRTWD1OMTjwfygGYtbZSRQF0DLg/RQDGf+j0kSDOxI4rc+2o/rZVif3Uc6UAVB2afs0xQfWb1LMYFM3E4BpfQaufY3ig+q1QBOL4qZdym5aXmhe5rbmHTPdJ5p2Wb9V2bp9OkVrxC2UAyQy8+ZKg/UjIiYCZ1HMHXgnxfO7O/At4NjMfKLCeBuJiJdTvIl9hafm/H0xcDTwtsy8rsJ4gyq7URxefm1NUbQtqnExT0Q8p7/tNR/Y2DvRfWbmo1Vn2ZRy8OjqzFxb3h4PTMyaTeEYEbOBd1MMuvx+y65tgXWZWcuBgdB/v/LebTWe5uy2zJzecjuAWzNzemv3oCZpWu6m5YXmZW533jHTUkzDLusDRMRLgHsy88dlv7v3U6zgchXFKmx19AlgC2C33gIiIrYFvgT8Q/lVJ/8IzM7MJS3bvh0R11CMMK/dSkS9ylb5U4BTIuLFwDkUv0+dp9+6nOIDaQBbUfy/vJ0aTi8I6/8PnkO5+E9EPAy8r+XSfx1dDbyGYuERKD4wXQW8orJE/fsh8FtgZ+DUlu2PUnRLqLNbI+IMiquOUAzgXl42CtR18NqSiLiMYpERKGae+F75Iar2A84H0LQuZE3LC83L3Na8Y6aluD8RsTPwYNb0l4yIHwOvycw/RsSrKP4Az6VYIWdaZtZuOp2IuIViCrk/9dk+iWKEdq1G7UfEzzPzBQPsq90k8a3KAVRvpGgpPohi6eRFmXlxlbmGo7wKclxm/k3VWfoTETcDf5uZ3y9vz6RYda3OV5Y2aqmsa+tlU0UxR/FxPDW14A8oPvg/DjwtM1cOdN+qlC3Db6Mlc9ZwefVW0aClqaF5eaF5mavO27EJkdstIvaPiCUR8c2IeHFZvN0C3B8Rb6g63wDGZ+Yfy5/fRdHP9b8y8x+A51WYazDr+rtMW75J1PHDx2CXw1cNsq8yEfHaiDiHYmnZoylaX/8sMw9vUkEMkJk/pujTWFdrewtigMxcSjGlY52tap0dISJmUMP5qyNiafn90Yh4pOXr0Yh4pOp8g8nMxzLz1Mx8a2a+lWKKzw9m5ro6FsRQ9P0p3z/+LjP/juK970tV59qEcyn68e9S3v45xWIvdXUuzcoLzct8LhXmHUvdJ/4d+DiwPcWa6m/MzOsi4oUUfTGvrDLcAMZHxIRyQOBBFIPBetX13yYjYjL9jwBd1+kwQ7Bb9L/aYVAselBHHwMuAE7MzBVVhxmOiDih5eY4ihH891UUZyi+FxFnUfyNSIoPp0t6i86yqK+bDwMXRkTvIkXPpMhdK5k5s/y+bdVZRiIink4x9/1sijfo2i5C06vsZjWbYgGMOynGU9RZk2ZegublheZlrjRvXQuvkZjQO01OOf3MdQCZ+bPiqlItLaJ4U/4DRUtP7yXc51HT2ScoPnTcSP9FcR1bij8yyL4bOpZieA6mWKHxn8rL++c0aCaV1gJoDUUr939VlGUo9i2/n9xn+4spXs8HdjbOpmXmj8oP+71df2q5SENE7DjY/parZLVRjo94G8UAwRdQFJVTM/PZlQYbRES8gKIQng38gaJVOzJzVqXBhqYxMy+VmpYXmpe50rxjpk9xtEzoHH0md+57u07Kf/BnAVdl5qpy2wuASTVtpVKbRcTXgSeApRR9iu/OzOOrTTU8EfG0us2G0J+IGN87i0PdRf+LM6yXNVudMSLu5KlBl31lZj63w5E2KSIeA/6XYkDx0szMiLijjll7lTMvfZ9iCrlflttqnblXk2ZegublheZlrjrvWGop3rfspxYUk9r39lnrHQVfS/1NCVbnKbdggwFgvfP+3gb8T11bMyPiSOB4nmpZWw78W2Z+rbpUg5qe5WqGEbGQ4k26EaKYAm8hMAl4TkTsC7w/M4+rNtmAfhER/0XRGr+86jCb8GY2vhrTW3AmNbtUnpmNmxGIouvS4RSLdywqP6DW3dsoMvdExJUUA7Zre3m0jxXAq2lZmppioHldNS0vNC9zpXnHTEuxOiMidqXos/1b4Caemvf3mcCszKxV/9GyIP4wxZLfvfMU/znweeCLWcNVnpp0paOviLieYiqoS/KpZZM3mvO1LsrL5YcDf03RB/ocYHFm1m4gWESc2GdTAr+naNG8s4JIQ1LOrLORzLy201mGKiKeS/G6mE2xSNHJwLfq3GBRzgB0CEXmAykW7vhW1nP1PQAi4kbgkMy8t7z9KuBLvY0CddO0vNC8zFXntSjWsETEucBPMvOLfbZ/CJiRmUdWEmwAEXEdcHhm3tVn+x4Uxc/+FcQaVDmooHdmjKCYh/ZPPLUQzXZVZduUiLg+M18WLROsR8RPM3PfTd23alHMFX4BsANwEfBPvZej6yAi+vZ7BtiRYhXBT2bm4n72Vy4iWpeg3gp4KXBjZtauv3Z/ImIvikLzXZlZ11mBNlAOhn4HReY6L5LyEopW+TdTNFb8M/CmzLyn0mADaFpeaF7mqvNaFGtYIuJnmfnCAfbVbt7f6LPK01D3aWQi4iLgCxSzwbyMotvKfpl5eKXBBhDFanAHU7QU70GxFO75wF8An8kB5riuk3JA23cbdDVhN4qrNG+vOstAoljw4rHMXFeO8XghcGXWbMXOXuXr+NaB/jbXWdnl6ixgNXBwZv6+4kiDalpeaF7mKvOOpT7F6ozB5kOt48CqwfLWbm7XMeBY4DSK6e7upVhp7W8rTTS4XwA9wOcz84ct2y8a6LJ/3WSx+E9T+pBCsVrntKpDbMK1wF+ULa5XAT+imObsiEpTDSAz10bE7RHxnKz5kuqw/upBa4vc0yhmGFgYEWTmIdUk61/T8kLzMtclr0Wxhmv7AUbBB1DHy/rTymnN+gqg9qOzmyYz/wC8p+ocw7DPQIsxZOaHOh1mJCJiFsXglFqKiNN56s1uHMWgmbrPrBOZ+aeImEOxwuHnIuKnVYfahMkUy1P/Ly0LE9Wt+Cn9S9UBhqlpeaF5mWuR16JYw/U9ir4+/anjwJm6t0iNCRHxj4Pszsz8p46FGYLWQq2/RtY6FsQRsYyNZ5/YkWJxlPd2PtGQtc4HvoZiqfIfVBVmiKK8hPseYE65re4rwP5D1QGGKjO/1/tzFMv6vqS8+b+Z+UA1qQbWtLzQvMx1yWufYkmbrZ+ZEQC2oSgodsrMSR2ONKhyVpJen6LP4h2ZeV5nE21aROzeZ1MCD/bOb67RUw66PBH4QWaeUs5G8eE6flhqVb5Gnp+Z342IpwHjM3Owpe4rFRHvpJgJaAnF1bu/AD6SmRdVmWsgTcsLzctcdV6LYg1LbLiM70Yy8wudyjIUEfEo/a+0V/uZHJqqnObseIqC+BvAqXVsmejVOlOGRs8ALdvw1P+9fTocaUyLiKOBY4AdM/PPIuL5wJk1n33ip8Bre/8+RLG09nfrOltN0/JC8zJXndfuExqubTd9SH1kZqPyNlk5C8IJFJeczwP+PDNr29e1hS0D7fGmqgMMV0R8MTM/3M+gH6C2/XN7/S3FdHfXA2TmLyLiGdVG2qRxfT4wP0i9u6k0LS80L3OleS2KNSyZ+amqM6h+IuLzFCtrfQXYe6DBa+oemXl31RlGoHcxn1oM+hmmxzPzid4+8uXKo3X/wHdlRPwPsKi8/S7gigrzbErT8kLzMlea1+4TGpamDahSZ0TEOuBxioFUrX9UatlNpU+3mqfx1HSCtczbRH2e49blqGv/HEfE8Zl52qa21UlEfA54iGLQ5VzgOOC2zJxfabBNiIi3A68sb34/M79VZZ5NaVpeaF7mKvNaFGtYmjagSpKGq7+l1eve9zwixlH8HX4dxQeP/wH+IxvwJh8R29Fy5Toz/1hhnE1qWl5oXuaq8loUa8SaNqBKUjUiYibFrAhfjYidgW0z886qc/UVEbOBdwMzge+37NoWWFfzQWvbAKszc215ezwwMTPruKgSABHxforZX1YD63jqKkIt55BvWl5oXuaq81oUa9j6GVB1WkMGVEnqsIg4GdgP2DMzXxARuwAXZuYrN3HXjiunNJsK/DNwUsuuR4GbM3NNJcGGICKuA17T258/IiYBV2XmK6pNNrCI+AXw8nLRn9prWl5oXuaq8zrQTsPigCpJw/RW4MWUq9hl5n3lVabaKQcH3g28vOosI7BV69/jzFxZzlVcZ7/iqf78TdC0vNC8zJXmtSjWcJ1IMaDqE8D8ltXAaj94RlIlnsjMjIjeFQS3qTrQQCJiaWbO7Gd+8yb8fVsVEX+emT8GiIgZwGMVZ9qUjwE/jIjrKd5XgHquKFlqWl5oXuZK81oUa1gys87zG0qqn29ExFnADuUCE+8Dzq44U78yc2b5vZYt2ZvwYeDCiLiPooh/JsV0VnV2FnANsIyi/2jdNS0vNC9zpXntUyxJGnUR8TxgSmb+ICJey1OzIjwCnJ+Zv6o0YD/K8RIDasCI/S2APcubt2fmk1Xm2ZS6z+jRV9PyQvMyV53XoliSNOoi4jLgY5m5rM/2vYHPZOabq0k2sIi4k6fmUu6rliP2I+Jtg+3PzG92KstwRcRngLuAS9nwUnktP3w0LS80L3PVeS2KJUmjLiJ+lJkvGWDfsszcu9OZxqKI+Cobr1y3frGUzHxfhyMNWfkhBPrkr+OHD2heXmhe5qrz2qdYktQOOwyyb+uOpRiBiHhVf9sz89pOZxmCW/rcTuD3wNI6zgUNEBEvAe7JzKnl7SOBt1O0EH6yumT9a1peaF7muuR10JQkqR1uKAfWbSAi/ga4sYI8w/GRlq9/oLiU+8kqAw1iUp+vbSnmhb4iIg6vMtggzgKegPUfQP6ZYs77hymm+6ybpuWF5mWuRV67T0iSRl1ETAG+RfFG11sE7wdsCbw1M39XVbbhiojdgC9m5turzjJU5aDB7/ZdrroOIuKnmblv+fOXgN9n5ifL2z/JzBdVma+vpuWF5mWuS15biiVJoy4z7y9XU/sUxSXQu4BPZebLm1QQl34DTKs6xHCUA5P6GzBYB+Mjorf75kEUU3D1qmO3zqblheZlrkXeOj4xkqQxIjN7gJ6qcwxHRJzOUwN9xgEvolyRrykiYhawouocA1gEfC8i/kCxwMj3Yf00fg9XGWwATcsLzctci7x2n5AkqUU5yKfXGuCuzPxBVXkGExHL2Hj2iR2B+4D3ZubPOp9q0yJif+BZwFWZuarc9gJgUu+qfHXStLzQvMx1yGtRLElSQ0XE7n02JfBgb1EhaegsiiVJYsBWVyj65mZm7tPhSJI6yKJYkiT6bXXdQGbe3akskjrPoliSJEldz9knJEkCIuJRnuo+sX6pZJ7qPrFdJcEkdYQtxZIkSep6Lt4hSVIfETEzIv66/HnniJhadSZJ7WVLsSRJLSLiZIolqffMzBdExC7AhZn5yoqjSWojW4olSdrQW4FDgFUAmXkfsG2liSS1nUWxJEkbeiKLy6gJEBHbVJxHUgdYFEuStKFvRMRZwA4RcTTwXeDsijNJajP7FEuSBETE84ApmfmDiHgt8DqK6dgeAc7PzF9VGlBSW1kUS5IERMRlwMcyc1mf7XsDn8nMN1eTTFIn2H1CkqTClL4FMUC5bY/Ox5HUSRbFkiQVdhhk39YdSyGpEhbFkiQVbigH1m0gIv4GuLGCPJI6yD7FkiQBETEF+BbwBE8VwfsBWwJvzczfVZVNUvtZFEuS1CIiZgF7lTdvzcxrqswjqTMsiiX9/+3aMQEAAABAsP6tBbGlcACAPU8xAAB7ohgAgD1RDADAnigGAGAv/rMQAKronCsAAAAASUVORK5CYII=\n",
            "text/plain": [
              "<Figure size 864x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FoxVoyQhP4CR",
        "colab_type": "text"
      },
      "source": [
        "Create two boxplots, the first of the 'UlcerAge' column and the second of the same column with the extremes trimmed. \n",
        "The same could be done with 'BMI' and 'CellulitisAge', however if all entries with extreme values in any of these three columns were removed \n",
        "there would be several hundred fewer entries. This would be feasible in a much larger data set."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ml-wvKk39wiq",
        "colab_type": "code",
        "outputId": "9b368423-f58d-409d-97c7-4de3e567a657",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 531
        }
      },
      "source": [
        "df[['UlcerAge']].boxplot()\n",
        "plt.show()\n",
        "std = df['UlcerAge'].std()\n",
        "mean = df['UlcerAge'].mean()\n",
        "cut_off = df['UlcerAge'].quantile(0.75) - df['UlcerAge'].quantile(0.25) # Can also do std * 3\n",
        "lower, upper = mean - cut_off, mean + cut_off\n",
        "trimmed_df = df[(df['UlcerAge'] < upper)\n",
        "                           & (df['UlcerAge'] > lower)]\n",
        "trimmed_df[['UlcerAge']].boxplot()\n",
        "plt.show()\n",
        "print(trimmed_df.shape)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "(605, 15)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rQcjPW5o3PaI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# X and y are formed, X is standardized, and training and testing sets are created.\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "# The features and target are separated into 'X' and 'y' and 'X' is standardized\n",
        "y = df['Ulcer'].copy().values #values makes dataframe into array to correct if order changes lose column names and index\n",
        "X = df.drop(['Ulcer'], axis=1).copy().values\n",
        "SS_scaler = StandardScaler()\n",
        "X = SS_scaler.fit_transform(X)\n",
        "X_train, X_test, y_train,  y_test = train_test_split(X, y, test_size=0.2, random_state=123, shuffle=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S70JuRDoTbwJ",
        "colab_type": "text"
      },
      "source": [
        "The optimal number of neighbors will be determined for the K-Nearest Neighbors classifier. The K-Nearest Neighbors classifier will be instantiated and fitted. The metrics will then be determined."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FcBS2ca6y8kH",
        "colab_type": "code",
        "outputId": "1636a641-a61c-4a64-ac79-4057e04ac09b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        }
      },
      "source": [
        "# We will optomize our three classifiers and then institute voting to achieve the best results\n",
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "from sklearn.linear_model import LogisticRegression\n",
        "from sklearn.tree import DecisionTreeClassifier\n",
        "from sklearn.ensemble import VotingClassifier, RandomForestClassifier\n",
        "from sklearn.metrics import precision_score, recall_score, f1_score, classification_report, confusion_matrix, mean_absolute_error, mean_squared_error, log_loss, accuracy_score\n",
        "from sklearn.model_selection import cross_val_score\n",
        "from sklearn.svm import SVC \n",
        " \n",
        "# Creating even list K for KNN.\n",
        "neighbors = list(range(2,50,2))\n",
        "# empty list that will hold cv scores\n",
        "cv_scores = [ ]\n",
        "#perform 10-fold cross-validation\n",
        "for K in neighbors:\n",
        "    knn = KNeighborsClassifier(n_neighbors = K)\n",
        "    scores = cross_val_score(knn,X_train,y_train,cv = 10,scoring =\n",
        "    \"accuracy\")\n",
        "    cv_scores.append(scores.mean())\n",
        "\n",
        "# Change to mse classification error.\n",
        "mse = [1-x for x in cv_scores]\n",
        "# determing best k\n",
        "optimal_k = neighbors[mse.index(min(mse))]\n",
        "print(\"The optimal no. of neighbors is {}.\".format(optimal_k))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The optimal no. of neighbors is 12.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BrQXXyffmPA7",
        "colab_type": "code",
        "outputId": "3c951ffc-488e-4e1b-d9eb-18e4ae4beba1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 390
        }
      },
      "source": [
        "# Instantiate and fit the K-Nearest Neighbors classifier.\n",
        "clf_knn = KNeighborsClassifier(n_neighbors=10)\n",
        "clf_knn.fit(X_train, y_train)\n",
        "knn_pred = clf_knn.predict(X_test)\n",
        "\n",
        "# Compare the K-Nearest Neighbors training and test accuracies.\n",
        "knn_pred_train_Y = clf_knn.predict(X_train)\n",
        "knn_pred_test_Y = clf_knn.predict(X_test)\n",
        "knn_train_accuracy = round(accuracy_score(y_train, knn_pred_train_Y), 3)\n",
        "knn_test_accuracy = round(accuracy_score(y_test, knn_pred_test_Y), 3)\n",
        "print('K-Nearest Neighbors Training Accuracy:', knn_train_accuracy)\n",
        "print('K-Nearest Neighbors Test Accuracy:', knn_test_accuracy)\n",
        "\n",
        "# Compare the K-Nearest Neighbors training and test precision and recall.\n",
        "knn_train_precision = round(precision_score(y_train, knn_pred_train_Y), 3)\n",
        "knn_test_precision = round(precision_score(y_test, knn_pred_test_Y), 3)\n",
        "knn_train_recall = round(recall_score(y_train, knn_pred_train_Y), 3)\n",
        "knn_test_recall = round(recall_score(y_test, knn_pred_test_Y), 3)\n",
        "print('K-Nearest Neighbors Training precision: {}, Training recall: {}'.format(knn_train_precision, knn_train_recall))\n",
        "print('K-Nearest Neighbors Test precision: {}, Test recall: {}'.format(knn_test_precision, knn_test_recall))\n",
        "\n",
        "# Calculate the F1-Score of the K-Nearest Neighbors classifier.\n",
        "score_knn = f1_score(y_test, knn_pred)\n",
        "print('K-Nearest Neighbors F1-Score: {:.3f}'.format(score_knn))\n",
        "\n",
        "# Calculate the mean absolute error of the K-Nearest Neighbors classifier.\n",
        "mae_knn = mean_absolute_error(y_test, knn_pred)\n",
        "print('K-Nearest Neighbors Log Loss: {:.3f}'.format(mae_knn))\n",
        "\n",
        "# Calculate the root mean square error of the K-Nearest Neighbors classifier.\n",
        "rmse_knn = mean_squared_error(y_test, knn_pred)\n",
        "print('K-Nearest Neighbors Root Mean Absolut Error: {:.3f}'.format(rmse_knn))\n",
        "\n",
        "# Calculate the log loss of the K-Nearest Neighbors classifier.\n",
        "ll_knn = log_loss(y_test, knn_pred)\n",
        "print('K-Nearest Neighbors Log Loss: {:.3f}'.format(ll_knn))\n",
        "\n",
        "# Calculate the classification report for the K-Nearest Neighbors classifier.\n",
        "report_knn = classification_report(y_test, knn_pred)\n",
        "print('K-Nearest Neighbors Classification Report:')\n",
        "print(report_knn)\n",
        "\n",
        "# Create a confusion matrix for the K-Nearest Neighbors classifier.\n",
        "conf_mat_knn = confusion_matrix(y_test, knn_pred)\n",
        "print('K-Nearest Neighbors Confusion Matrix:')\n",
        "print(conf_mat_knn)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "K-Nearest Neighbors Training Accuracy: 0.811\n",
            "K-Nearest Neighbors Test Accuracy: 0.822\n",
            "K-Nearest Neighbors Training precision: 0.683, Training recall: 0.215\n",
            "K-Nearest Neighbors Test precision: 0.375, Test recall: 0.12\n",
            "K-Nearest Neighbors F1-Score: 0.182\n",
            "K-Nearest Neighbors Log Loss: 0.178\n",
            "K-Nearest Neighbors Root Mean Absolut Error: 0.178\n",
            "K-Nearest Neighbors Log Loss: 6.135\n",
            "K-Nearest Neighbors Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.85      0.96      0.90       127\n",
            "           1       0.38      0.12      0.18        25\n",
            "\n",
            "    accuracy                           0.82       152\n",
            "   macro avg       0.61      0.54      0.54       152\n",
            "weighted avg       0.77      0.82      0.78       152\n",
            "\n",
            "K-Nearest Neighbors Confusion Matrix:\n",
            "[[122   5]\n",
            " [ 22   3]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "psW_QqWrryxn",
        "colab_type": "code",
        "outputId": "876e89d6-88d1-40a7-abb2-68cf4f7fa22d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "# Determine the K-Nearest Neighbors cross validation score.  \n",
        "def knn_scorer(clf_knn, X, y):\n",
        "  return accuracy_score(y, clf_knn.predict(X))\n",
        "# Check how the K-Nearest Neighbors classifier performs with 5 fold cross-validation.\n",
        "knn_kfold = cross_val_score(clf_knn, X, y, cv=5, scoring=knn_scorer)\n",
        "# Print the K-Nearest Neighbors mean accuracy per fold.\n",
        "print('K-Nearest Neighbors Mean Accuracy Per Fold:', knn_kfold.mean())\n",
        "# Print the K-Nearest Neighbors standard deviation per fold.\n",
        "print('K-Nearest Neighbors Standard Deviation Per Fold:', knn_kfold.std())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "K-Nearest Neighbors Mean Accuracy Per Fold: 0.799738584872778\n",
            "K-Nearest Neighbors Standard Deviation Per Fold: 0.00304717804183953\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uhpV4UXUVVSI",
        "colab_type": "text"
      },
      "source": [
        "The optimal value of C will be determined for the Logistic Regression classifier. The trade-off parameter of logistic regression that determines the strength of the regularization is called C, \n",
        "and higher values of C correspond to less regularization (where we can specify the regularization function).\n",
        "C is actually the Inverse of regularization strength(lambda) \n",
        "liblinear — Library for Large Linear Classification. It uses a coordinate descent algorithm. Coordinate descent is based on \n",
        "minimizing a multivariate function by solving univariate optimization problems in a loop. - it is included here so that one can have flexibility for small and large data sets. The Logistic Regression classifier will be instantiated and fitted. The metrics will then be determined."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CZBvdz13hvsv",
        "colab_type": "code",
        "outputId": "683ddff4-5211-4f74-f1ec-d2ad0a6f4ed3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 195
        }
      },
      "source": [
        "C = [1, .5, .25, .1, .05, .025, .01, .005, .0025]\n",
        "l1_metrics = np.zeros((len(C), 3))\n",
        "l1_metrics[:,0] = C\n",
        " # Run a for loop over the range of C list length\n",
        "for index in range(0, len(C)):\n",
        "  # Initialize and fit Logistic Regression with the C candidate\n",
        "  logreg = LogisticRegression(penalty='l1', C=C[index], solver='liblinear')\n",
        "  logreg.fit(X_train, y_train)\n",
        "  # Predict ulcers on the testing data\n",
        "  pred_test_Y = logreg.predict(X_test)\n",
        "  # Create non-zero count and recall score columns\n",
        "  l1_metrics[index,1] = np.count_nonzero(logreg.coef_)\n",
        "  l1_metrics[index,2] = recall_score(y_test, pred_test_Y)\n",
        "\n",
        "# Name the columns and print the array as a pandas DataFrame.\n",
        "col_names = ['C','Non-Zero Coeffs','Recall']\n",
        "print(pd.DataFrame(l1_metrics, columns=col_names))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "        C  Non-Zero Coeffs  Recall\n",
            "0  1.0000             12.0    0.56\n",
            "1  0.5000             12.0    0.56\n",
            "2  0.2500             11.0    0.52\n",
            "3  0.1000              9.0    0.44\n",
            "4  0.0500              8.0    0.16\n",
            "5  0.0250              2.0    0.00\n",
            "6  0.0100              0.0    0.00\n",
            "7  0.0050              0.0    0.00\n",
            "8  0.0025              0.0    0.00\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tRDATxwynC9j",
        "colab_type": "code",
        "outputId": "747a5279-d642-403f-e281-b6784ee50d90",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 390
        }
      },
      "source": [
        "# Instantiate and fit the Logistic Regression classifier.\n",
        "clf_lr = LogisticRegression(class_weight='balanced', penalty='l1', C=0.2500, solver='liblinear', random_state=500)\n",
        "clf_lr.fit(X_train, y_train)\n",
        "lr_pred = clf_lr.predict(X_test)\n",
        "\n",
        "# Compare the Logistic Regression training and test accuracies.\n",
        "lr_pred_train_Y = clf_lr.predict(X_train)\n",
        "lr_pred_test_Y = clf_lr.predict(X_test)\n",
        "lr_train_accuracy = round(accuracy_score(y_train, lr_pred_train_Y), 3)\n",
        "lr_test_accuracy = round(accuracy_score(y_test, lr_pred_test_Y), 3)\n",
        "print('Logistic Regression Training Accuracy:', lr_train_accuracy)\n",
        "print('Logistic Regression Test Accuracy:', lr_test_accuracy)\n",
        "\n",
        "# Compare the Logistic Regression training and test precision and recall.\n",
        "lr_train_precision = round(precision_score(y_train, lr_pred_train_Y), 3)\n",
        "lr_test_precision = round(precision_score(y_test, lr_pred_test_Y), 3)\n",
        "lr_train_recall = round(recall_score(y_train, lr_pred_train_Y), 3)\n",
        "lr_test_recall = round(recall_score(y_test, lr_pred_test_Y), 3)\n",
        "print('Training precision: {}, Training recall: {}'.format(lr_train_precision, lr_train_recall))\n",
        "print('Test precision: {}, Test recall: {}'.format(lr_test_precision, lr_test_recall))\n",
        "\n",
        "# Calculate the F1-Score of the Logistic Regression classifier.\n",
        "score_lr = f1_score(y_test, lr_pred)\n",
        "print('Logistic Regression F1-Score: {:.3f}'.format(score_lr))\n",
        "\n",
        "# Calculate the mean absolute error of the Logistic Regression classifier.\n",
        "mae_lr = mean_absolute_error(y_test, lr_pred)\n",
        "print('Logistic Regression Log Loss: {:.3f}'.format(mae_lr))\n",
        "\n",
        "# Calculate the root mean square error of the Logistic Regression classifier.\n",
        "rmse_lr = mean_squared_error(y_test, lr_pred)\n",
        "print('Logistic Regression Root Mean Absolut Error: {:.3f}'.format(rmse_lr))\n",
        "\n",
        "# Calculate the log loss of the Logistic Regression classifier.\n",
        "ll_lr = log_loss(y_test, lr_pred)\n",
        "print('Logistic Regression Log Loss: {:.3f}'.format(ll_lr))\n",
        "\n",
        "# Calculate the classification report for the Logistic Regression classifier.\n",
        "report_lr = classification_report(y_test, lr_pred)\n",
        "print('Logistic Regression Classification Report:')\n",
        "print(report_lr)\n",
        "\n",
        "# Create a confusion matrix for the Logistic Regression classifier.\n",
        "conf_mat_lr = confusion_matrix(y_test, lr_pred)\n",
        "print('Logistic Regression Confusion Matrix:')\n",
        "print(conf_mat_lr)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Logistic Regression Training Accuracy: 0.937\n",
            "Logistic Regression Test Accuracy: 0.914\n",
            "Training precision: 0.838, Training recall: 0.877\n",
            "Test precision: 0.714, Test recall: 0.8\n",
            "Logistic Regression F1-Score: 0.755\n",
            "Logistic Regression Log Loss: 0.086\n",
            "Logistic Regression Root Mean Absolut Error: 0.086\n",
            "Logistic Regression Log Loss: 2.954\n",
            "Logistic Regression Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.96      0.94      0.95       127\n",
            "           1       0.71      0.80      0.75        25\n",
            "\n",
            "    accuracy                           0.91       152\n",
            "   macro avg       0.84      0.87      0.85       152\n",
            "weighted avg       0.92      0.91      0.92       152\n",
            "\n",
            "Logistic Regression Confusion Matrix:\n",
            "[[119   8]\n",
            " [  5  20]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KVw7hqWlr9-z",
        "colab_type": "code",
        "outputId": "9dfe3e00-964e-4b97-bb64-887320571727",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "# Determine the Logistic Regression cross validation score.  \n",
        "def lr_scorer(clf_lr, X, y):\n",
        "  return accuracy_score(y, clf_lr.predict(X))\n",
        "# Check how the Logistic Regression classifier performs with 5 fold cross-validation.\n",
        "lr_kfold = cross_val_score(clf_lr, X, y, cv=5, scoring=lr_scorer)\n",
        "# Print the Logistic Regression mean accuracy per fold.\n",
        "print('Logistic Regression Mean Accuracy Per Fold:', lr_kfold.mean())\n",
        "# Print the Logistic Regression standard deviation per fold.\n",
        "print('Logistic Regression Standard Deviation Per Fold:', lr_kfold.std())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Logistic Regression Mean Accuracy Per Fold: 0.91313175322412\n",
            "Logistic Regression Standard Deviation Per Fold: 0.03510902806716738\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fySwagdMVe6l",
        "colab_type": "text"
      },
      "source": [
        "The maximal depth will be determined for the Decision Tree classifier. The Decision Tree classifier will be instantiated and fitted. The metrics will then be determined."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eKv7YMpkY_2f",
        "colab_type": "code",
        "outputId": "cacc58c5-9b41-4cfb-fe2c-12d6d699f9d6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 248
        }
      },
      "source": [
        "depth_list = list(range(2,14))\n",
        "depth_tuning = np.zeros((len(depth_list), 2))\n",
        "depth_tuning[:,0] = depth_list\n",
        "\n",
        "# Run a for loop over the range of depth list length.\n",
        "for index in range(0, len(depth_list)):\n",
        "  # Initialize and fit decision tree with the `max_depth` candidate.\n",
        "  decide = DecisionTreeClassifier(max_depth=depth_list[index])  \n",
        "  decide.fit(X_train, y_train)\n",
        "  # Predict ulcers on the testing data.\n",
        "  ex_pred_test_Y = decide.predict(X_test)\n",
        "  # Calculate the recall score \n",
        "  depth_tuning[index,1] = recall_score(y_test, ex_pred_test_Y)\n",
        "\n",
        "# Name the columns and print the array as a pandas DataFrame.\n",
        "col_names = ['Max_Depth','Recall']\n",
        "print(pd.DataFrame(depth_tuning, columns=col_names))\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "    Max_Depth  Recall\n",
            "0         2.0    0.40\n",
            "1         3.0    0.16\n",
            "2         4.0    0.36\n",
            "3         5.0    0.40\n",
            "4         6.0    0.48\n",
            "5         7.0    0.44\n",
            "6         8.0    0.56\n",
            "7         9.0    0.56\n",
            "8        10.0    0.48\n",
            "9        11.0    0.48\n",
            "10       12.0    0.48\n",
            "11       13.0    0.48\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YhXQ8MgsnFl_",
        "colab_type": "code",
        "outputId": "f45821d7-b57a-404d-8b98-fc92bada497b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 390
        }
      },
      "source": [
        "# Instantiate and fit the Decision Tree classifier.\n",
        "clf_dt = DecisionTreeClassifier(min_samples_leaf=3, min_samples_split=4, max_depth=11, random_state=500)\n",
        "clf_dt.fit(X_train, y_train)\n",
        "dt_pred = clf_dt.predict(X_test)\n",
        "\n",
        "# Compare the Decision Tree training and test accuracies.\n",
        "dt_pred_train_Y = clf_dt.predict(X_train)\n",
        "dt_pred_test_Y = clf_dt.predict(X_test)\n",
        "dt_train_accuracy = accuracy_score(y_train, dt_pred_train_Y)\n",
        "dt_test_accuracy = accuracy_score(y_test, dt_pred_test_Y)\n",
        "print('Decision Tree Training Accuracy:', dt_train_accuracy)\n",
        "print('Decision Tree Test Accuracy:', dt_test_accuracy)\n",
        "\n",
        "# Compare the Decision Tree training and test precision and recall.\n",
        "dt_train_precision = round(precision_score(y_train, dt_pred_train_Y), 3)\n",
        "dt_test_precision = round(precision_score(y_test, dt_pred_test_Y), 3)\n",
        "dt_train_recall = round(recall_score(y_train, dt_pred_train_Y), 3)\n",
        "dt_test_recall = round(recall_score(y_test, dt_pred_test_Y), 3)\n",
        "print('Decision Tree Training precision: {}, Training recall: {}'.format(dt_train_precision, dt_train_recall))\n",
        "print('Decision Tree Test precision: {}, Test recall: {}'.format(dt_test_precision, dt_test_recall))\n",
        "\n",
        "# Calculate the F1-Score of the Decision Tree classifier.\n",
        "score_dt = f1_score(y_test, dt_pred)\n",
        "print('Decision Tree F1-Score: {:.3f}'.format(score_dt))\n",
        "\n",
        "# Calculate the mean absolute error of the Decision Tree classifier.\n",
        "mae_dt = mean_absolute_error(y_test, dt_pred)\n",
        "print('Decision Tree Log Loss: {:.3f}'.format(mae_dt))\n",
        "\n",
        "# Calculate the root mean square error of the Decision Tree classifier.\n",
        "rmse_dt = mean_squared_error(y_test, dt_pred)\n",
        "print('Decision Tree Root Mean Absolute Error: {:.3f}'.format(rmse_dt))\n",
        "\n",
        "# Calculate the log loss of the Decision Tree classifier.\n",
        "ll_dt = log_loss(y_test, dt_pred)\n",
        "print('Decision Tree Log Loss: {:.3f}'.format(ll_dt))\n",
        "\n",
        "# Calculate the classification report for the Decision Tree classifier.\n",
        "report_dt = classification_report(y_test, dt_pred)\n",
        "print('Decision Tree Classification Report:')\n",
        "print(report_dt)\n",
        "\n",
        "# Create a confusion matrix for the Decision Tree classifier.\n",
        "conf_mat_dt = confusion_matrix(y_test, dt_pred)\n",
        "print('Decision Tree Confusion Matrix:')\n",
        "print(conf_mat_dt)\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Decision Tree Training Accuracy: 0.9489291598023064\n",
            "Decision Tree Test Accuracy: 0.8618421052631579\n",
            "Decision Tree Training precision: 0.884, Training recall: 0.877\n",
            "Decision Tree Test precision: 0.577, Test recall: 0.6\n",
            "Decision Tree F1-Score: 0.588\n",
            "Decision Tree Log Loss: 0.138\n",
            "Decision Tree Root Mean Absolute Error: 0.138\n",
            "Decision Tree Log Loss: 4.772\n",
            "Decision Tree Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.92      0.91      0.92       127\n",
            "           1       0.58      0.60      0.59        25\n",
            "\n",
            "    accuracy                           0.86       152\n",
            "   macro avg       0.75      0.76      0.75       152\n",
            "weighted avg       0.86      0.86      0.86       152\n",
            "\n",
            "Decision Tree Confusion Matrix:\n",
            "[[116  11]\n",
            " [ 10  15]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lvE0dNntsKZF",
        "colab_type": "code",
        "outputId": "cb7d6903-6179-446f-a16d-9c7281ad147b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "# Determine the Decision Tree cross validation score.  \n",
        "def dt_scorer(clf_dt, X, y):\n",
        "  return accuracy_score(y, clf_dt.predict(X))\n",
        "# Check how the Decision Tree classifier performs with 5 fold cross-validation.\n",
        "dt_kfold = cross_val_score(clf_dt, X, y, cv=5, scoring=dt_scorer)\n",
        "# Print the Decision Tree mean accuracy per fold.\n",
        "print('Decision Tree Mean Accuracy Per Fold:', dt_kfold.mean())\n",
        "# Print the Decision Tree standard deviation per fold.\n",
        "print('Decision Tree Standard Deviation Per Fold:', dt_kfold.std())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mean Accuracy Per Fold: 0.8300801673056813\n",
            "Standard Deviation Per Fold: 0.031064947054359266\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I_0RzIdtVirt",
        "colab_type": "text"
      },
      "source": [
        "The Support Vector Machine classifier will be instantiated and fitted. The metrics will then be determined.  Support Vector Machine (SVM) is a supervised machine learning algorithm which can be used for both classification or regression challenges. \n",
        " However,  it is mostly used in classification problems. In the SVM algorithm, we plot each data item as a point in n-dimensional space \n",
        " (where n is number of features you have) with the value of each feature being the value of a particular coordinate. \n",
        " Then, we perform classification by finding the hyper-plane that differentiates the two classes very well. Support Vectors are simply the co-ordinates of individual observation. \n",
        "The SVM classifier is a frontier which best segregates the two classes (hyper-plane/ line)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CSlyu2hH_jVF",
        "colab_type": "code",
        "outputId": "7179dd25-66f9-4800-c70e-8599f64b5b2f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 390
        }
      },
      "source": [
        "# Instantiate and fit the Support Vector Machine classifier.\n",
        "clf_svm = SVC(probability=True, class_weight='balanced', random_state=500)\n",
        "clf_svm.fit(X_train, y_train)\n",
        "svm_pred = clf_svm.predict(X_test)\n",
        "\n",
        "# Compare the Support Vector Machine training and test accuracies.\n",
        "svm_pred_train_Y = clf_svm.predict(X_train)\n",
        "svm_pred_test_Y = clf_svm.predict(X_test)\n",
        "svm_train_accuracy = accuracy_score(y_train, svm_pred_train_Y)\n",
        "svm_test_accuracy = accuracy_score(y_test, svm_pred_test_Y)\n",
        "print('Support Vector Machine Training Accuracy:', svm_train_accuracy)\n",
        "print('Support Vector Machine Test Accuracy:', svm_test_accuracy)\n",
        "\n",
        "# Compare the Support Vector Machine training and test precision and recall.\n",
        "svm_train_precision = round(precision_score(y_train, svm_pred_train_Y), 3)\n",
        "svm_test_precision = round(precision_score(y_test, svm_pred_test_Y), 3)\n",
        "svm_train_recall = round(recall_score(y_train, svm_pred_train_Y), 3)\n",
        "svm_test_recall = round(recall_score(y_test, svm_pred_test_Y), 3)\n",
        "print('Support Vector Machine Training precision: {}, Training recall: {}'.format(svm_train_precision, svm_train_recall))\n",
        "print('Support Vector Machine Test precision: {}, Test recall: {}'.format(svm_test_precision, svm_test_recall))\n",
        "\n",
        "# Calculate the F1-Score of the Support Vector Machine classifier.\n",
        "score_svm = f1_score(y_test, svm_pred)\n",
        "print('Support Vector Machine F1-Score: {:.3f}'.format(score_svm))\n",
        "\n",
        "# Calculate the mean absolute error of the Support Vector Machine classifier.\n",
        "mae_svm = mean_absolute_error(y_test, svm_pred)\n",
        "print('Support Vector Machine Log Loss: {:.3f}'.format(mae_svm))\n",
        "\n",
        "# Calculate the root mean square error of the Support Vector Machine classifier.\n",
        "rmse_svm = mean_squared_error(y_test, svm_pred)\n",
        "print('Support Vector Machine Root Mean Absolute Error: {:.3f}'.format(rmse_svm))\n",
        "\n",
        "# Calculate the log loss of the Support Vector Machine classifier.\n",
        "ll_svm = log_loss(y_test, svm_pred)\n",
        "print('Support Vector Machine Log Loss: {:.3f}'.format(ll_svm))\n",
        "\n",
        "# Calculate the classification report for the Support Vector Machine classifier.\n",
        "report_svm = classification_report(y_test, svm_pred)\n",
        "print('Support Vector Machine Classification Report:')\n",
        "print(report_svm)\n",
        "\n",
        "# Create a confusion matrix for the Support Vector Machine classifier.\n",
        "conf_mat_svm = confusion_matrix(y_test, svm_pred)\n",
        "print('Support Vector Machine Confusion Matrix:')\n",
        "print(conf_mat_svm)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Support Vector Machine Training Accuracy: 0.8121911037891268\n",
            "Support Vector Machine Test Accuracy: 0.7039473684210527\n",
            "Support Vector Machine Training precision: 0.543, Training recall: 0.777\n",
            "Support Vector Machine Test precision: 0.308, Test recall: 0.64\n",
            "Support Vector Machine F1-Score: 0.416\n",
            "Support Vector Machine Log Loss: 0.296\n",
            "Support Vector Machine Root Mean Absolute Error: 0.296\n",
            "Support Vector Machine Log Loss: 10.225\n",
            "Support Vector Machine Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.91      0.72      0.80       127\n",
            "           1       0.31      0.64      0.42        25\n",
            "\n",
            "    accuracy                           0.70       152\n",
            "   macro avg       0.61      0.68      0.61       152\n",
            "weighted avg       0.81      0.70      0.74       152\n",
            "\n",
            "Support Vector Machine Confusion Matrix:\n",
            "[[91 36]\n",
            " [ 9 16]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8rhLjhiEsOf3",
        "colab_type": "code",
        "outputId": "531025be-ff37-438d-deef-f9b1bb02ec25",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "# Determine the Support Vector Machine cross validation score.  \n",
        "def svm_scorer(clf_svm, X, y):\n",
        "  return accuracy_score(y, clf_svm.predict(X))\n",
        "# Check how the Support Vector Machine performs with 5 fold cross-validation\n",
        "svm_kfold = cross_val_score(clf_svm, X, y, cv=5, scoring=svm_scorer)\n",
        "# Print the Support Vector Machine mean accuracy per fold\n",
        "print('Support Vector Machine Mean Accuracy Per Fold:', svm_kfold.mean())\n",
        "# Print the standard deviation per fold\n",
        "print('Support Vector Machine Standard Deviation Per Fold:', svm_kfold.std())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Support Vector Machine Mean Accuracy Per Fold: 0.7537120948065528\n",
            "Support Vector Machine Standard Deviation Per Fold: 0.03985630054247557\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mVy7EDubVl9G",
        "colab_type": "text"
      },
      "source": [
        "The optimal number of neighbors will be determined for the voting classifier. The voting classifier will be instantiated and fitted. The metrics will then be determined."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k5fbn2FyfULb",
        "colab_type": "code",
        "outputId": "c8d1f877-d1c8-4111-9cc6-6c161659a0d0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 319
        }
      },
      "source": [
        " # Create and fit the voting classifier.\n",
        "clf_vote = VotingClassifier(\n",
        "    estimators=[('knn', clf_knn), ('lr',clf_lr), ('dt', clf_dt), ('svm', clf_svm)]\n",
        ")\n",
        "clf_vote.fit(X_train, y_train)\n",
        "pred_vote = clf_vote.predict(X_test)\n",
        "\n",
        "# Calculate the F1-Score of the voting classifier.\n",
        "score_vote = f1_score(y_test, pred_vote)\n",
        "print('Voting Classifier F1-Score: {:.3f}'.format(score_vote))\n",
        "\n",
        "# Calculate the mean absolute error of the voting classifier.\n",
        "mae_vote = mean_absolute_error(y_test, pred_vote)\n",
        "print('Voting Classifier Log Loss: {:.3f}'.format(mae_vote))\n",
        "\n",
        "# Calculate the root mean square error of the voting classifier.\n",
        "rmse_vote = mean_squared_error(y_test, pred_vote)\n",
        "print('Voting Classifier Root Mean Absolute Error: {:.3f}'.format(rmse_vote))\n",
        "\n",
        "# Calculate the log loss of the voting classifier.\n",
        "ll_vote = log_loss(y_test, pred_vote)\n",
        "print('Voting Classifier Log Loss: {:.3f}'.format(ll_vote))\n",
        "\n",
        "# Calculate the classification report for the voting classifier.\n",
        "report_vote = classification_report(y_test, pred_vote)\n",
        "print('Voting Classifier Classification Report:')\n",
        "print(report_vote)\n",
        "\n",
        "# Create a confusion matrix for the voting classifier.\n",
        "conf_mat_vote = confusion_matrix(y_test, pred_vote)\n",
        "print('Voting Classifier Confusion Matrix:')\n",
        "print(conf_mat_vote)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Voting Classifier F1-Score: 0.524\n",
            "Voting Classifier Log Loss: 0.132\n",
            "Voting Classifier Root Mean Absolute Error: 0.132\n",
            "Voting Classifier Log Loss: 4.545\n",
            "Voting Classifier Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.90      0.95      0.92       127\n",
            "           1       0.65      0.44      0.52        25\n",
            "\n",
            "    accuracy                           0.87       152\n",
            "   macro avg       0.77      0.70      0.72       152\n",
            "weighted avg       0.86      0.87      0.86       152\n",
            "\n",
            "Voting Classifier Confusion Matrix:\n",
            "[[121   6]\n",
            " [ 14  11]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aFN5xqBatTRF",
        "colab_type": "code",
        "outputId": "0038823a-1ae5-42f7-d612-b35a9da29067",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 52
        }
      },
      "source": [
        "# Determine the voting cross validation score.  \n",
        "def vote_scorer(clf_vote, X, y):\n",
        "  return accuracy_score(y, clf_vote.predict(X))\n",
        "# Check how the voting model performs with 5 fold cross-validation.\n",
        "vote_kfold = cross_val_score(clf_vote, X, y, cv=5, scoring=vote_scorer)\n",
        "# Print the mean voting accuracy per fold.\n",
        "print('Voting Accuracy Per Fold:', vote_kfold.mean())\n",
        "# Print the voting standard deviation per fold.\n",
        "print('Voting Standard Deviation Per Fold:', vote_kfold.std())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Voting Accuracy Per Fold: 0.8472028581387242\n",
            "Voting Standard Deviation Per Fold: 0.019462059223270947\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SayBjlbJVpIB",
        "colab_type": "text"
      },
      "source": [
        "The Random Forest classifier is another ensemble classifier. It will be instantiated and fitted. The metrics will then be determined."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3Jq5pUxnBW_o",
        "colab_type": "code",
        "outputId": "31e4e4e2-e3a8-4181-c545-d16c91cce7e1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 390
        }
      },
      "source": [
        "# Instantiate and fit the Random Forest classifier.\n",
        "clf_rf = RandomForestClassifier(n_estimators=15, max_features=10, oob_score=10 , max_depth=15 ,min_samples_split=4 , min_samples_leaf=4 , class_weight= ('balanced') )  \n",
        "clf_rf.fit(X_train, y_train)\n",
        "rf_pred = clf_rf.predict(X_test)\n",
        "\n",
        "# Compare the Random Forest training and test accuracies.\n",
        "rf_pred_train_Y = clf_rf.predict(X_train)\n",
        "rf_pred_test_Y = clf_rf.predict(X_test)\n",
        "rf_train_accuracy = accuracy_score(y_train, rf_pred_train_Y)\n",
        "rf_test_accuracy = accuracy_score(y_test, rf_pred_test_Y)\n",
        "print('Random Forest Training Accuracy:', rf_train_accuracy)\n",
        "print('Random Forest Test Accuracy:', rf_test_accuracy)\n",
        "\n",
        "# Compare the Random Forest training and test precision and recall.\n",
        "rf_train_precision = round(precision_score(y_train, rf_pred_train_Y), 4)\n",
        "rf_test_precision = round(precision_score(y_test, rf_pred_test_Y), 4)\n",
        "rf_train_recall = round(recall_score(y_train, rf_pred_train_Y), 4)\n",
        "rf_test_recall = round(recall_score(y_test, rf_pred_test_Y), 4)\n",
        "print('Random Forest Training precision: {}, Training recall: {}'.format(rf_train_precision, dt_train_recall))\n",
        "print('Random Forest Test precision: {}, Test recall: {}'.format(rf_test_precision, dt_test_recall))\n",
        "\n",
        "# Calculate the F1-Score of the Random Forest classifier.\n",
        "score_rf = f1_score(y_test, rf_pred)\n",
        "print('Random Forest F1-Score: {:.3f}'.format(score_rf))\n",
        "\n",
        "# Calculate the mean absolute error of the Random Forest classifier.\n",
        "mae_rf = mean_absolute_error(y_test, rf_pred)\n",
        "print('Random Forest Log Loss: {:.3f}'.format(mae_rf))\n",
        "\n",
        "# Calculate the root mean square error of the Random Forest classifier.\n",
        "rmse_rf = mean_squared_error(y_test, rf_pred)\n",
        "print('Random Forest Root Mean Absolute Error: {:.3f}'.format(rmse_rf))\n",
        "\n",
        "# Calculate the log loss of the Random Forest classifier.\n",
        "ll_rf = log_loss(y_test, rf_pred)\n",
        "print('Random Forest Log Loss: {:.3f}'.format(ll_rf))\n",
        "\n",
        "# Calculate the classification report for the Random Forest classifier.\n",
        "report_rf = classification_report(y_test, rf_pred)\n",
        "print('Random Forest Classification Report:')\n",
        "print(report_rf)\n",
        "\n",
        "# Create a confusion matrix for the Random Forest classifier.\n",
        "conf_mat_rf = confusion_matrix(y_test, rf_pred)\n",
        "print('Random Forest Confusion Matrix:')\n",
        "print(conf_mat_rf)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Random Forest Training Accuracy: 0.9522240527182867\n",
            "Random Forest Test Accuracy: 0.8421052631578947\n",
            "Random Forest Training precision: 0.8741, Training recall: 0.8769\n",
            "Random Forest Test precision: 0.52, Test recall: 0.6\n",
            "Random Forest F1-Score: 0.520\n",
            "Random Forest Log Loss: 0.158\n",
            "Random Forest Root Mean Absolute Error: 0.158\n",
            "Random Forest Log Loss: 5.454\n",
            "Random Forest Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.91      0.91      0.91       127\n",
            "           1       0.52      0.52      0.52        25\n",
            "\n",
            "    accuracy                           0.84       152\n",
            "   macro avg       0.71      0.71      0.71       152\n",
            "weighted avg       0.84      0.84      0.84       152\n",
            "\n",
            "Random Forest Confusion Matrix:\n",
            "[[115  12]\n",
            " [ 12  13]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ieinzB6cGcRB",
        "colab_type": "code",
        "outputId": "d13060d6-6ac3-4fad-dbef-7ce0257c6619",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 195
        }
      },
      "source": [
        "# Determine the Random Forest cross validation score.  \n",
        "def rf_scorer(clf_rf, X, y):\n",
        "  return accuracy_score(y, clf_rf.predict(X))\n",
        "# Check how the Random Forest model performs with 5 fold cross-validation.\n",
        "rf_kfold = cross_val_score(clf_rf, X, y, cv=5, scoring=rf_scorer)\n",
        "# Print the Random Forest mean accuracy per fold.\n",
        "print('Random Forest Mean Accuracy Per Fold:', rf_kfold.mean())\n",
        "# Print the Random Forest standard deviation per fold.\n",
        "print('Random Forest Standard Deviation Per Fold:', rf_kfold.std())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Random Forest Mean Accuracy Per Fold: 0.8524311606831649\n",
            "Random Forest Standard Deviation Per Fold: 0.019824660340189728\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/sklearn/ensemble/_forest.py:523: UserWarning: Some inputs do not have OOB scores. This probably means too few trees were used to compute any reliable oob estimates.\n",
            "  warn(\"Some inputs do not have OOB scores. \"\n",
            "/usr/local/lib/python3.6/dist-packages/sklearn/ensemble/_forest.py:528: RuntimeWarning: invalid value encountered in true_divide\n",
            "  predictions[k].sum(axis=1)[:, np.newaxis])\n",
            "/usr/local/lib/python3.6/dist-packages/sklearn/ensemble/_forest.py:523: UserWarning: Some inputs do not have OOB scores. This probably means too few trees were used to compute any reliable oob estimates.\n",
            "  warn(\"Some inputs do not have OOB scores. \"\n",
            "/usr/local/lib/python3.6/dist-packages/sklearn/ensemble/_forest.py:528: RuntimeWarning: invalid value encountered in true_divide\n",
            "  predictions[k].sum(axis=1)[:, np.newaxis])\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5yxZz4U4jX_M",
        "colab_type": "text"
      },
      "source": [
        "The following table contains a summary of the metrics. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0GBl--RoOL9T",
        "colab_type": "code",
        "outputId": "21e653c7-d37d-47ca-9b18-7f3e6b96752d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 338
        }
      },
      "source": [
        "print('Summary of Classifier Results:')\n",
        "data = {'Classifier':['K-Nearest Neighbors', 'Logistic Regression', 'Decision Tree', 'Support Vector Machine', 'Voting', 'Random Forest'],\n",
        "        'Training Accuracy':[knn_train_accuracy, lr_train_accuracy, dt_train_accuracy, svm_train_accuracy, '', rf_train_accuracy], \n",
        "        'Test Accuracy':[knn_test_accuracy, lr_test_accuracy, dt_test_accuracy, svm_test_accuracy, '', rf_test_accuracy], \n",
        "        'Training Precision':[knn_train_precision, lr_train_precision, dt_train_precision, svm_train_precision, '', rf_train_precision], \n",
        "        'Training Recall':[knn_train_recall, lr_train_recall, dt_train_recall, svm_train_recall, '', rf_train_recall], \n",
        "        'Test Precision':[knn_test_precision, lr_test_precision, dt_test_precision, svm_test_precision, '', rf_test_precision], \n",
        "        'Test Recall':[knn_test_recall, lr_test_recall, dt_test_recall, svm_test_recall, '', rf_test_recall], \n",
        "        'F1-Score':[score_knn, score_lr, score_dt, score_svm, score_vote, score_rf], \n",
        "        'Mean Absolute Error':[mae_knn, mae_lr, mae_dt, mae_svm, mae_vote, mae_rf], \n",
        "        'Root Mean Square Error':[rmse_knn, rmse_lr, rmse_dt, rmse_svm, rmse_vote, rmse_rf], \n",
        "        'Log Loss':[ll_knn, ll_lr, ll_dt, ll_svm, ll_vote, ll_rf], \n",
        "        'Cross Validation Mean Accuracy':[knn_kfold.mean(), lr_kfold.mean(), dt_kfold.mean(), svm_kfold.mean(), vote_kfold.mean(), rf_kfold.mean()],\n",
        "        'Cross Validation Standard Deviation':[knn_kfold.std(), lr_kfold.std(), dt_kfold.std(), svm_kfold.std(), vote_kfold.std(), rf_kfold.std()]}\n",
        "summary = pd.DataFrame(data)\n",
        "summary.set_index('Classifier')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Summary of Classifier Results:\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "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>Training Accuracy</th>\n",
              "      <th>Test Accuracy</th>\n",
              "      <th>Training Precision</th>\n",
              "      <th>Training Recall</th>\n",
              "      <th>Test Precision</th>\n",
              "      <th>Test Recall</th>\n",
              "      <th>F1-Score</th>\n",
              "      <th>Mean Absolute Error</th>\n",
              "      <th>Root Mean Square Error</th>\n",
              "      <th>Log Loss</th>\n",
              "      <th>Cross Validation Mean Accuracy</th>\n",
              "      <th>Cross Validation Standard Deviation</th>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Classifier</th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "      <th></th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>K-Nearest Neighbors</th>\n",
              "      <td>0.810544</td>\n",
              "      <td>0.822368</td>\n",
              "      <td>0.6829</td>\n",
              "      <td>0.2154</td>\n",
              "      <td>0.375</td>\n",
              "      <td>0.12</td>\n",
              "      <td>0.181818</td>\n",
              "      <td>0.177632</td>\n",
              "      <td>0.177632</td>\n",
              "      <td>6.135204</td>\n",
              "      <td>0.799739</td>\n",
              "      <td>0.003047</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Logistic Regression</th>\n",
              "      <td>0.937397</td>\n",
              "      <td>0.914474</td>\n",
              "      <td>0.8382</td>\n",
              "      <td>0.8769</td>\n",
              "      <td>0.7143</td>\n",
              "      <td>0.8</td>\n",
              "      <td>0.754717</td>\n",
              "      <td>0.085526</td>\n",
              "      <td>0.085526</td>\n",
              "      <td>2.954016</td>\n",
              "      <td>0.913132</td>\n",
              "      <td>0.035109</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Decision Tree</th>\n",
              "      <td>0.948929</td>\n",
              "      <td>0.861842</td>\n",
              "      <td>0.8837</td>\n",
              "      <td>0.8769</td>\n",
              "      <td>0.5769</td>\n",
              "      <td>0.6</td>\n",
              "      <td>0.588235</td>\n",
              "      <td>0.138158</td>\n",
              "      <td>0.138158</td>\n",
              "      <td>4.771862</td>\n",
              "      <td>0.830080</td>\n",
              "      <td>0.031065</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Support Vector Machine</th>\n",
              "      <td>0.812191</td>\n",
              "      <td>0.703947</td>\n",
              "      <td>0.543</td>\n",
              "      <td>0.7769</td>\n",
              "      <td>0.3077</td>\n",
              "      <td>0.64</td>\n",
              "      <td>0.415584</td>\n",
              "      <td>0.296053</td>\n",
              "      <td>0.296053</td>\n",
              "      <td>10.225485</td>\n",
              "      <td>0.753712</td>\n",
              "      <td>0.039856</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Voting</th>\n",
              "      <td></td>\n",
              "      <td></td>\n",
              "      <td></td>\n",
              "      <td></td>\n",
              "      <td></td>\n",
              "      <td></td>\n",
              "      <td>0.523810</td>\n",
              "      <td>0.131579</td>\n",
              "      <td>0.131579</td>\n",
              "      <td>4.544607</td>\n",
              "      <td>0.847203</td>\n",
              "      <td>0.019462</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>Random Forest</th>\n",
              "      <td>0.952224</td>\n",
              "      <td>0.842105</td>\n",
              "      <td>0.8741</td>\n",
              "      <td>0.9077</td>\n",
              "      <td>0.52</td>\n",
              "      <td>0.52</td>\n",
              "      <td>0.520000</td>\n",
              "      <td>0.157895</td>\n",
              "      <td>0.157895</td>\n",
              "      <td>5.453554</td>\n",
              "      <td>0.852431</td>\n",
              "      <td>0.019825</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>"
            ],
            "text/plain": [
              "                       Training Accuracy  ... Cross Validation Standard Deviation\n",
              "Classifier                                ...                                    \n",
              "K-Nearest Neighbors             0.810544  ...                            0.003047\n",
              "Logistic Regression             0.937397  ...                            0.035109\n",
              "Decision Tree                   0.948929  ...                            0.031065\n",
              "Support Vector Machine          0.812191  ...                            0.039856\n",
              "Voting                                    ...                            0.019462\n",
              "Random Forest                   0.952224  ...                            0.019825\n",
              "\n",
              "[6 rows x 12 columns]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KaEQAnkrjl9c",
        "colab_type": "text"
      },
      "source": [
        "The following is a summary of the classification reports."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-N5FYdTuQBnn",
        "colab_type": "code",
        "outputId": "348fc62c-8f0b-4a55-991f-42d9b706b152",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        }
      },
      "source": [
        "print('Review of Classification Reports:')\n",
        "print('K-Nearest Neighbors Classification Report:')\n",
        "print(report_knn)\n",
        "print('Logistic Regression Classification Report:')\n",
        "print(report_lr)\n",
        "print('Decision Tree Classification Report:')\n",
        "print(report_dt)\n",
        "print('Support Vector Machine Classification Report:')\n",
        "print(report_svm)\n",
        "print('Voting Classification Report:')\n",
        "print(report_vote)\n",
        "print('Random Forest Classification Report:')\n",
        "print(report_rf)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Review of Classification Reports:\n",
            "K-Nearest Neighbors Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.85      0.96      0.90       127\n",
            "           1       0.38      0.12      0.18        25\n",
            "\n",
            "    accuracy                           0.82       152\n",
            "   macro avg       0.61      0.54      0.54       152\n",
            "weighted avg       0.77      0.82      0.78       152\n",
            "\n",
            "Logistic Regression Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.96      0.94      0.95       127\n",
            "           1       0.71      0.80      0.75        25\n",
            "\n",
            "    accuracy                           0.91       152\n",
            "   macro avg       0.84      0.87      0.85       152\n",
            "weighted avg       0.92      0.91      0.92       152\n",
            "\n",
            "Decision Tree Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.92      0.91      0.92       127\n",
            "           1       0.58      0.60      0.59        25\n",
            "\n",
            "    accuracy                           0.86       152\n",
            "   macro avg       0.75      0.76      0.75       152\n",
            "weighted avg       0.86      0.86      0.86       152\n",
            "\n",
            "Support Vector Machine Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.91      0.72      0.80       127\n",
            "           1       0.31      0.64      0.42        25\n",
            "\n",
            "    accuracy                           0.70       152\n",
            "   macro avg       0.61      0.68      0.61       152\n",
            "weighted avg       0.81      0.70      0.74       152\n",
            "\n",
            "Voting Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.90      0.95      0.92       127\n",
            "           1       0.65      0.44      0.52        25\n",
            "\n",
            "    accuracy                           0.87       152\n",
            "   macro avg       0.77      0.70      0.72       152\n",
            "weighted avg       0.86      0.87      0.86       152\n",
            "\n",
            "Random Forest Classification Report:\n",
            "              precision    recall  f1-score   support\n",
            "\n",
            "           0       0.91      0.91      0.91       127\n",
            "           1       0.52      0.52      0.52        25\n",
            "\n",
            "    accuracy                           0.84       152\n",
            "   macro avg       0.71      0.71      0.71       152\n",
            "weighted avg       0.84      0.84      0.84       152\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OYjceDlbjw_a",
        "colab_type": "text"
      },
      "source": [
        "The following is a summary of the confusion matrices."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VZZXLY6dr6XI",
        "colab_type": "code",
        "outputId": "b0d54e49-165f-472a-b86d-1bb932781586",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        }
      },
      "source": [
        "print('Review of Confusion Matrices:')\n",
        "print('K-Nearest Neighbors Confusion Matrix:')\n",
        "print(conf_mat_knn)\n",
        "print('Logistic Regression Confusion Matrix:')\n",
        "print(conf_mat_lr)\n",
        "print('Decision Tree Confusion Matrix:')\n",
        "print(conf_mat_dt)\n",
        "print('Support Vector Machine Confusion Matrix:')\n",
        "print(conf_mat_svm)\n",
        "print('Voting Confusion Matrix:')\n",
        "print(conf_mat_vote)\n",
        "print('Random Forest Confusion Matrix:')\n",
        "print(conf_mat_rf)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Review of Confusion Matrices:\n",
            "K-Nearest Neighbors Confusion Matrix:\n",
            "[[122   5]\n",
            " [ 22   3]]\n",
            "Logistic Regression Confusion Matrix:\n",
            "[[119   8]\n",
            " [  5  20]]\n",
            "Decision Tree Confusion Matrix:\n",
            "[[116  11]\n",
            " [ 10  15]]\n",
            "Support Vector Machine Confusion Matrix:\n",
            "[[91 36]\n",
            " [ 9 16]]\n",
            "Voting Confusion Matrix:\n",
            "[[121   6]\n",
            " [ 14  11]]\n",
            "Random Forest Confusion Matrix:\n",
            "[[115  12]\n",
            " [ 12  13]]\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}