FUR_final.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Focus on FUR and FCS Transactions  \n",
    "\n",
    "by Fred Etter - November, 2019"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import modules\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import numpy as np\n",
    "from sklearn import linear_model\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn import preprocessing\n",
    "import sklearn\n",
    "from sklearn.feature_selection import SelectFromModel\n",
    "from datetime import datetime\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read in the data\n",
    "\n",
    "df = pd.read_csv('sends.csv', low_memory=False)\n",
    "df_march = pd.read_csv('march.csv', low_memory=False)\n",
    "df_april = pd.read_csv('april.csv', low_memory=False)\n",
    "df_may = pd.read_csv('may.csv', low_memory=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create new dataframs for fcs and fur transactions - JUST FOR MARCH\n",
    "df_fcs = df_march.loc[df_march['ACTIVITY_TYPE'] == 'FCS']\n",
    "df_fur = df_march.loc[df_march['ACTIVITY_TYPE'] == 'FUR']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a dataframe that captures all transactions for all 3 months\n",
    "df_t1_all = pd.concat([df_march, df_april], sort=False)\n",
    "df_t_all = pd.concat([df_t1_all, df_may], sort=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# all transactions has almost 5 million rows\n",
    "df_t_all.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# build new dataframe for all months for fcs and fur\n",
    "df_t_all_fcs = df_t_all.loc[df_t_all['ACTIVITY_TYPE'] == 'FCS']\n",
    "df_t_all_fur = df_t_all.loc[df_t_all['ACTIVITY_TYPE'] == 'FUR']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# look at sample data for all fcs transactions\n",
    "\n",
    "pd.set_option('display.max_columns', None)\n",
    "print(df_t_all_fcs.shape)\n",
    "df_t_all_fcs.sample(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# getting unique supporter_ids for all fcs transactions\n",
    "df_dd = df_t_all_fcs.drop_duplicates(subset='SUPPORTER_ID')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is the number of unique supporters who made a FCS transaction - 22433\n",
    "df_dd.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_dd.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_dd.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_dd.reset_index(inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_dd.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_dd.drop(columns=['index', 'COUNTRY', 'ACTIVITY_TYPE', 'ACTIVITY_DATETIME', 'ACTIVITY_ID', 'ACTIVITY_STATUS', 'ACTIVITY_DATA_1', \n",
    "                   'ACTIVITY_DATA_2', 'ACTIVITY_DATA_3', 'ACTIVITY_DATA_4', 'ACTIVITY_DATA_6', 'ACTIVITY_DATA_7', 'ACTIVITY_DATA_8',\n",
    "                   'ACTIVITY_DATA_9', 'ACTIVITY_DATA_10', 'ACTIVITY_DATA_26', 'ACTIVITY_DATA_27', 'ACTIVITY_DATA_28', \n",
    "                   'ACTIVITY_DATA_29', 'ACTIVITY_DATA_30'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = df_dd.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.SUPPORTER_ID.nunique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# renaming some columns\n",
    "df1 = df1.rename(columns={'SUPPORTER_ID': 'supp_id', 'ACTIVITY_DATA_5': 'currency'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### FUR or not ?  (1 or 0):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add the column 'fur' where it equals 1 if the supporter also contributed monthly (has a FUR transaction)\n",
    "df1['fur'] = np.where(df1.supp_id.isin(df_t_all_fur.SUPPORTER_ID), 1, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# display number of rows, columns for supporters who made a FCS and FUR transaction\n",
    "df1.loc[df1['fur'] == 1].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Number of FCS transactions by unique supporter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "df_temp = df_t_all_fcs.groupby('SUPPORTER_ID').count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = df1.merge(df_temp[['ACTIVITY_ID']], left_on=df1.supp_id, right_on=df_temp.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.drop(columns=['key_0'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# renaming some columns\n",
    "df1 = df1.rename(columns={'ACTIVITY_ID': 'total_fcs'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Maximum FCS transaction:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_temp = pd.DataFrame()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_temp['max_fcs'] = df_t_all_fcs.groupby('SUPPORTER_ID', sort=False)['ACTIVITY_DATA_26'].max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_temp.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_temp.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = df1.merge(df_temp, left_on=['supp_id'], right_on=df_temp.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Total transactions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_temp = df_t_all.groupby('SUPPORTER_ID').count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = df1.merge(df_temp[['ACTIVITY_ID']], left_on=df1.supp_id, right_on=df_temp.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# drop unnecessary column\n",
    "df1.drop(columns=['key_0'], inplace=True)\n",
    "\n",
    "# renaming some columns\n",
    "df1 = df1.rename(columns={'ACTIVITY_ID': 'total_trans'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sum of total FCS donations by supporter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_temp = pd.DataFrame()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_temp['sum_fcs'] = df_t_all_fcs.groupby('SUPPORTER_ID', sort=False)['ACTIVITY_DATA_26'].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = df1.merge(df_temp, left_on=['supp_id'], right_on=df_temp.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Number of Ps:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_p = df_t_all.loc[df_t_all['ACTIVITY_STATUS'] == 'P']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_p = df_p.groupby('SUPPORTER_ID', sort=False).count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_p.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = df1.merge(df_p['ACTIVITY_ID'], how='left', left_on='supp_id', right_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# renaming some columns\n",
    "df1 = df1.rename(columns={'ACTIVITY_ID': 'num_P'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Number of 'formsub' transactions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create new df for only 'formsub' actions\n",
    "df_fs = df_t_all.loc[df_t_all['ACTIVITY_DATA_3'] == 'formsub']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_fs = df_fs.groupby('SUPPORTER_ID', sort=False).count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = df1.merge(df_fs['ACTIVITY_ID'], how='left', left_on='supp_id', right_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# renaming some columns\n",
    "df1 = df1.rename(columns={'ACTIVITY_ID': 'num_fs'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Number of clicks:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create new df with just transactions with a click\n",
    "df_c = df_t_all.loc[df_t_all['ACTIVITY_DATA_2'] == 'click']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_c = df_c.groupby('SUPPORTER_ID', sort=False).count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = df1.merge(df_c['ACTIVITY_ID'], how='left', left_on='supp_id', right_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# renaming some columns\n",
    "df1 = df1.rename(columns={'ACTIVITY_ID': 'num_c'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### A summary of some of the findings:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are **4935216** total transactions.\n",
    "\n",
    "There are **1002034** supporters involved in all transactions.\n",
    "\n",
    "There are **26971** FCS transactions total.\n",
    "\n",
    "There are **22433** supporters who made a FCS transaction.\n",
    "\n",
    "There are **188** FUR transactions total.\n",
    "    - 187 are ACTIVITY_ID 24029 (24029 has no other ACTIVITY_TYPE)\n",
    "    - 1 is ACTIVITY_ID 15348 (15348 also only has the 1 FUR ACTIVITY_TYPE)\n",
    "\n",
    "There are **174** supporters who made a FUR transaction.\n",
    "\n",
    "There are **21** FUR supporters who also made a FCS contribution.  \n",
    "\n",
    "All FUR transactions are in **GBP** currency."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following graph shows the number of FUR transactions, number of supporters who made those transactions, and the number of supporters who made both a FCS and FUR transaction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "actions = [188, 174, 21]\n",
    "index = ['FUR_transactions', 'FUR_Unique_supporters', 'FUR_and_FCS_supporters']\n",
    "df = pd.DataFrame({'actions': actions}, index=index)\n",
    "ax = df.plot.bar(rot=0, figsize=(12, 6))\n",
    "ax.set_axisbelow(True)\n",
    "ax.minorticks_on()\n",
    "ax.grid(which='major', linestyle='-', linewidth='0.5', color='red')\n",
    "plt.xlabel(\"Transactions\")\n",
    "plt.ylabel('Occurrences')\n",
    "plt.title(\"FUR transactions vs FUR unique supporters vs FUR and FCS supporters\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Some additional analysis...."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# display the number of unique supporter IDs from all transaction data:\n",
    "df_t_all.ACTIVITY_ID.nunique()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As shown above, the total number of activity IDs for the transaction data is **1144**.  This contrasts significantly with the number of unique activity IDs for the sends broadcast data in March of **43**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is the lone FUR supporter who does not have the 24029 ACTIVITY_ID (this person only has 1 transaction)\n",
    "df_t_all.loc[df_t_all['ACTIVITY_ID'] == 15348].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell above, just checking to see all of the transactions for activity ID 15348.  This was the one activity ID that had a FUR transaction that was not activity ID number 24029."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# show those supporters who made a single donation and those who made a rucurring donation as well (fur = 1)\n",
    "df1.loc[df1['fur'] == 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Something to note in the above dataframe:  the total transactions for all of these supporters is a high number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.total_trans.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.loc[df1['fur'] == 1].total_trans.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As shown above, the mean number of transactions for all FCS supporters is **14.5**, whereas the mean number of FCS supporters who also made a recurring donation (FUR) is **21.1**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusion - Part 1\n",
    "\n",
    "I wanted to use the dataframe below to perform machine learning / predictive analytics to try to find correlations between supporters who made FCS donations and those who made FUR donations.\n",
    "\n",
    "However, there are only **21** supporters who made a FCS and FUR donation (from Cell number 15 above).  This is 21 supporters out of a total of **22433** (from cell 17) who made a FCS transaction.  This seems like too little data to run a ML algorithm.\n",
    "\n",
    "Regardless, the framework / code is here to add to the dataframe below by creating more columns as needed.  See the dataframe below: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head(15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above dataframe has all unique supporters who made a FCS transaction.  The columns are as follows:\n",
    "\n",
    "  - supp_id = SUPPORTER_ID who made a FCS transaction\n",
    "  - num_fcs = number of FCS transactions total\n",
    "  - fur = if supporter made at least 1 FUR transaction, a 1 is placed, otherwise 0\n",
    "  - max_fcs = maximum FCS contribution amount in USD\n",
    "  - total_fcs = total FCS contribution amount in USD\n",
    "  - total_trans = total number of transactions made by that supporter\n",
    "  - currency = currency of donation\n",
    "  - num_p = number of 'P' transactions by the supporter\n",
    "  - num_fs = number of 'formsub' transactions by the supporter\n",
    "  - num_c = number of 'click' transactions by the supporter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Machine Learning - predict a FUR transaction given all FCS supporter data  \n",
    "\n",
    "One major caveat:  the FUR 1 or 0 does not consider if the FUR transaction occurred before or after the FCS transaction.\n",
    "\n",
    "#### Logistic Regression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = df1.fillna(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find the number of fur's to drop, so that the number of fur's and fcs's are equal\n",
    "n = df1.shape[0] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# number of rows where fur equals 1\n",
    "m = df1.loc[df1['fur'] == 1].shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this is the number of rows that needs to be subtracted from df1 so that FURs = FCSs\n",
    "number = n - m - m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# drop the correct amount of fur's so the number of FURs = FCSs.\n",
    "df1 = df1.drop(df1.query('fur == 0').sample(number).index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# drop currency for now\n",
    "df1.drop(columns=['currency'], inplace=True)\n",
    "df1.drop(columns=['supp_id'], inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create training and test sets.\n",
    "offset = int(df1.shape[0] * 0.8)\n",
    "\n",
    "df_train = df1[:offset]\n",
    "df_test = df1[offset:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_test.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1.  Logistic Regression\n",
    "\n",
    "start_time = datetime.now()\n",
    "\n",
    "# Instantiate our model.\n",
    "regr = linear_model.LogisticRegression(solver='sag')\n",
    "\n",
    "# set features and dependent variable for training data\n",
    "y_train = df_train['fur'].values\n",
    "\n",
    "# drop the 'target' column to obtain the feature inputs\n",
    "df_train.drop(['fur'], axis=1, inplace=True)\n",
    "\n",
    "# normalize the training data\n",
    "x_train = sklearn.preprocessing.normalize(df_train)\n",
    "\n",
    "# now for test...\n",
    "y_test = df_test['fur'].values\n",
    "\n",
    "# drop the 'target' column to obtain the feature inputs\n",
    "df_test.drop(['fur'], axis=1, inplace=True)\n",
    "\n",
    "# normalize the test data\n",
    "x_test = sklearn.preprocessing.normalize(df_test)\n",
    "\n",
    "# fit model to training data\n",
    "regr.fit(x_train, y_train)\n",
    "\n",
    "end_time = datetime.now()\n",
    "print('\\nDuration: {}'.format(end_time - start_time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a variable that is the 1 or 0 prediction from the model \n",
    "y_test_pred = regr.predict(x_test)\n",
    "sklearn.metrics.roc_auc_score(y_test, y_test_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create the Confusion Matrix\n",
    "sklearn.metrics.confusion_matrix(y_test, y_test_pred, labels=None, sample_weight=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# determine the accuracy classification score\n",
    "sklearn.metrics.accuracy_score(y_test, y_test_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Extra Trees Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.  Extra Trees Classifier\n",
    "\n",
    "start_time = datetime.now()\n",
    "\n",
    "from sklearn.ensemble import ExtraTreesClassifier\n",
    "\n",
    "# Instantiate our model.\n",
    "etc = ExtraTreesClassifier(n_estimators=1000)\n",
    "\n",
    "# fit model to data\n",
    "etc.fit(x_train, y_train)\n",
    "\n",
    "from sklearn.metrics import confusion_matrix\n",
    "sklearn.metrics.confusion_matrix(y_test, y_test_pred, labels=None, sample_weight=None)\n",
    "\n",
    "end_time = datetime.now()\n",
    "print('\\nDuration: {}'.format(end_time - start_time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_pred = etc.predict(x_test)\n",
    "sklearn.metrics.roc_auc_score(y_test, y_test_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sklearn.metrics.confusion_matrix(y_test, y_test_pred, labels=None, sample_weight=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sklearn.metrics.accuracy_score(y_test, y_test_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Forest Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.  Random Forest Classifier\n",
    "\n",
    "start_time = datetime.now()\n",
    "\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "# Instantiate our model.\n",
    "rfc = RandomForestClassifier(n_estimators=1000)\n",
    "\n",
    "# fit model to data\n",
    "rfc.fit(x_train, y_train)\n",
    "\n",
    "#------------------------------------------------------------------------------\n",
    "sfm = SelectFromModel(rfc, threshold=0.001, max_features=7)\n",
    "sfm.fit(x_train, y_train)\n",
    "sfm.get_support()\n",
    "selected_feat = df_train.columns[(sfm.get_support())]\n",
    "len(selected_feat)\n",
    "print(selected_feat)\n",
    "#------------------------------------------------------------------------------\n",
    "\n",
    "feature_importances = pd.DataFrame(rfc.feature_importances_,\n",
    "                                   index = df_train.columns,\n",
    "                                    columns=['importance']).sort_values('importance', ascending=False)\n",
    "\n",
    "\n",
    "end_time = datetime.now()\n",
    "print('\\nDuration: {}'.format(end_time - start_time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using 'feature_importances_' from random forest\n",
    "# these are the most important features and their relative importance for making the prediction\n",
    "print((feature_importances).head(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_test_pred = rfc.predict(x_test)\n",
    "sklearn.metrics.roc_auc_score(y_test, y_test_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sklearn.metrics.confusion_matrix(y_test, y_test_pred, labels=None, sample_weight=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sklearn.metrics.accuracy_score(y_test, y_test_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusion - Part 2\n",
    "\n",
    "So, I did end up doing some predictive modeling as shown above despite the sparse amount of supporters who made a single AND recurring contribution.  \n",
    "The results can very significantly becasue each time the models are executed they are chosing only a small subset of the total data.  However, the accuracy measures have been in the range of **55 - 92%**.  This is just a starting point.  Two different scores were analyzed:  area under the roc curve and the accuracy classification score based on the Confusion Matrix.  \n",
    "\n",
    "This accuracy represents the ability of each model to predict whether a supporter will make a recurring (FUR) donation based on the 7 featurers (columns in the final df1 dataframe) that were collected from the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}