F0D-16-LogisticRegression.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FLIP (00): Data Science \n",
    "**(Module 03: Linear Algebra)**\n",
    "\n",
    "---\n",
    "- Materials in this module include resources collected from various open-source online repositories.\n",
    "- You are free to use,but NOT allowed to change and distribute this package.\n",
    "\n",
    "Prepared by and for \n",
    "**Student Members** |\n",
    "2006-2023 [TULIP Lab](http://www.tulip.org.au), Australia\n",
    "\n",
    "---\n",
    "## Session 23 Logistic Regression"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##  <span style=\"color:black;\"> Logit function:</span>\n",
    "A logit function is simply a function of the mean of the response variable Y that we use as the response instead of Y itself.\n",
    "\n",
    "Because Y is a categorical binary variable and we need to predict in percentages, the logistic model uses the logit function to help us transform it into a response between 0 and 1\n",
    "\n",
    "In the formula below: $\\beta_{0} + \\beta_{1}X_{1} $ for simple logisitic regression can be changed for multiple logisitic regression for the linear compination of independent variables $\\beta_{0} + \\beta_{1}X_{1} + \\beta_{2}X_{2} + \\dotso + \\beta_{k}X_{k } $ They signify the linear compination of the independent variables.\n",
    "\n",
    "\n",
    "\n",
    " $ Ln  \\bigg( \\dfrac{{P}} {1 - P} \\bigg) = \\beta_{0} + \\beta_{1}X_{1}  $ \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:black;\">Visualizing the logit:</span>\n",
    "> $ logit(x) = Ln  \\bigg( \\dfrac{{x}} {1 - x} \\bigg)  $"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from pylab import *\n",
    "p_x = np.arange(0.0001,0.999999999,0.0001).tolist()\n",
    "\n",
    "r_y = [np.log(i/(1-i)) for i in p_x]\n",
    "\n",
    "def set_data_source(r_x,r_y):\n",
    "    return ColumnDataSource(\n",
    "        data=dict(\n",
    "            x=r_x, \n",
    "            y=r_y,\n",
    "        )\n",
    "    )\n",
    "    \n",
    "def plot(l_x = [], l_y = [], s_x = [], s_y = [],\n",
    "         width = 600,height = 400, \n",
    "         x_label = \"\", y_label = \"\", title = \"\", \n",
    "         line = False, scatter = False):\n",
    "\n",
    "    plot = figure(plot_width=width, plot_height=height, \n",
    "              x_axis_label = x_label,\n",
    "                y_axis_label = y_label,\n",
    "              title=title,\n",
    "            )\n",
    "    if line:\n",
    "        l_source = set_data_source(l_x,l_y)\n",
    "        plot.line('x','y', source = l_source)\n",
    "        \n",
    "    if scatter:\n",
    "        s_source = set_data_source(s_x,s_y)\n",
    "        plot.circle('x', 'y', size=15, source = s_source)\n",
    "        \n",
    "    show(plot)\n",
    "\n",
    "plot(p_x,r_y,[],[],400,400,\"Percentages\",\"\", \"Logit function: Ln(P/1-P)\", True)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see it is reaching to -inf and inf as we get close to 0 and 1\n",
    "\n",
    "Then we compute the inverse logit because we want our percentage as the Y variable / dependent. \n",
    "\n",
    "The inverse log of the the logit function allows us to find estimated regression equation.\n",
    "\n",
    "$ \\dfrac{{P}} {1 - P} = e^{\\beta_{0} + \\beta_{1}X_{1}}  $ \n",
    "\n",
    "$ P = e^{\\beta_{0} + \\beta_{1}X_{1} } \\big( {1 - P} \\big) $ \n",
    "\n",
    "\n",
    "... Until we end up with the estimated regression equation\n",
    "\n",
    "$ \\widehat{P} = \\dfrac{e^{\\beta_{0} + \\beta_{1}X_{1}}} {1 + e^{\\beta_{0} + \\beta_{1}X_{1}} } $\n",
    "\n",
    "\n",
    "\n",
    "### <span style=\"color:black;\">Visualizing the inverse logit:</span>\n",
    "> $ logit^{-1}(a) = \\dfrac{e^{a} } {1 + e^{a}}  $\n",
    "\n",
    "> We can see below that the function forms a sigmoid curve or S curve\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p_x = np.arange(-10,10,0.001).tolist()\n",
    "\n",
    "r_y = [np.exp(i)/(1+np.exp(i)) for i in p_x]\n",
    "\n",
    "plot(p_x,r_y,[],[],600,400,\"\",\"Percentages\",\"Inverse Logit function: e(a)/1-e(a)\", True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:black;\"> A simple example calculated </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets say we are an individual applying for a loan in an Icelandic bank and\n",
    "want to know the probability of our creditscore getting us a loan at the bank.\n",
    "\n",
    "We have our individual credit scores and their categorical binary value.\n",
    "##### Data for each applicant:\n",
    "* x-axis: Icelandic credit score points ranging 100(bad credit score) to 400(excellent)\n",
    "* y-axis: Approved as 1 or 0\n",
    "\n",
    "You can get your individual credit score from [Credit Info](https://www.creditinfo.is)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the data in\n",
    "from pandas import *\n",
    "data = pd.read_csv(\"F:\\Recourse\\Logistic-Regression-master\\Logistic-Regression-master\\loans.csv\")\n",
    "\n",
    "df = data.loc[:,('accepted','creditscore')]\n",
    "x_credit_scores = df.creditscore.values.tolist()\n",
    "y_zeroes_and_ones = df.accepted.values.tolist()\n",
    "\n",
    "sample_size = sum(df.accepted.value_counts())\n",
    "\n",
    "plot([],[],x_credit_scores,y_zeroes_and_ones, 800, 400, \n",
    "     \"Credit score points\",\"Accepted\",\"Credit Scores of \" + str(sample_size) + \" individuals on a scatter plot\",\n",
    "    False, True)\n",
    "\n",
    "print(\"Our data has\", sample_size, \"rows\")\n",
    "print(df.accepted.value_counts())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we want to plot the line but first we need to find out our coefficients.\n",
    "\n",
    "The regression coefficients represent the change in the logit for each unit change in the predictor(i.e.indepenent variable)\n",
    "\n",
    "The regression coefficients for logistic regression are calculated using maximum likelihood estimation or MLE. That is a topic of machine learning algorithms and a whole other lecture. If you want more info on MLE from\n",
    "statsmodel you can call print(result.mle_settings). Our example reveales that MLE uses the Newton optimizer.\n",
    "\n",
    "\n",
    "We can use the Logit function in statsmodel to get the coefficients for us.\n",
    "\n",
    "Lets look at the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df.head(), '\\n')\n",
    "print (df.describe(), '\\n')\n",
    "# print (\"Std deviation:\",df.std(), sep='\\n')\n",
    "print (\"Std deviation:\",df.std())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Count accepted vs. not accepted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df.accepted.value_counts())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Histograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make histograms from the data\n",
    "df.hist()\n",
    "\n",
    "pl.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Finding the slope (b) and intercept (b0) of the best-fitting equation\n",
    "* We will be using the maximum-likelihood method through the Logit method in statsmodel\n",
    "\n",
    "> ##### According to the statsmodel docs on the Logit method:\n",
    "    An intercept is not included by default so it should be added by the user."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['intercept'] = 1.00\n",
    "\n",
    "train_cols = df.loc[:,('creditscore','intercept')]\n",
    "# Index(['creditscore', 'intercept'], dtype='object')\n",
    "#dfm = dfm.loc[:,('accepted','creditscore','amount','age','marital','health_ins')]\n",
    "\n",
    "# the Logit uses the Newton optimizer in Maximum Likelihood Estimation (MLE), \n",
    "# (see print(result.mle_settings) )\n",
    "\n",
    "logit = sm.Logit(df['accepted'], train_cols)\n",
    "\n",
    "result = logit.fit()\n",
    "coef_arr = result.params.values\n",
    "#credit_coef, intercept_coef = np.split(coef_arr,2)\n",
    "#print(result.resid_generalized)\n",
    "print(result.summary())\n",
    "#print( result.conf_int())\n",
    "#print( np.exp(result.params))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**From our output we get a <u>positive</u> coefficient slope for the credit score.**\n",
    "\n",
    "**That means that the probability of getting a loan <u>increases</u> as we get a higher credit score.**\n",
    "\n",
    "If we have P>|z| value of 0.000 which is higher then 0.001 and then that indipendent variable is significant."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    " ##### Now we can put the coefficients into the estimated regression equation:\n",
    "$$ \\widehat{P} = \\dfrac{e^{\\beta_{0} + \\beta_{1}X_{1}}} {1 + e^{\\beta_{0} + \\beta_{1}X_{1}} } $$\n",
    "\n",
    " $$ X_{1} \\text{is the value we want to test}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Input we want to test\n",
    "test_x = [230]\n",
    "\n",
    "def phat(coef_arr,test_x_arr):\n",
    "    coef_arr, intercept = coef_arr[:-1],coef_arr[-1]\n",
    "    slopes = sum(list(c * x for c,x in zip(coef_arr,test_x_arr)))\n",
    "    ''' # Testings; use if you want to test\n",
    "    slopes = 0\n",
    "    for c,x in zip(coef_arr, test_x_arr):\n",
    "        print(c,\"*\",x)\n",
    "        slopes = slopes + c * x\n",
    "        print(\"slopes:\",slopes)'''\n",
    "    \n",
    "    a = intercept + slopes\n",
    "    return np.exp(a) / (1 + np.exp(a))\n",
    "\n",
    "p_hat = phat(coef_arr,test_x)\n",
    "print(p_hat,\"\\n\")\n",
    "print(\"Someone with a credit score of\", test_x, \"has an estimated probabilty of\", \"%0.2f\" % (p_hat*100), \"% to get a loan.\" )\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Odds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "odds = p_hat/(1-p_hat)\n",
    "print(\"odds for \",test_x, \"are:\", odds, \"to 1 or\", Fraction(odds),\"to 1\")\n",
    "\n",
    "'''Then lets take someone with 231'''\n",
    "test2_x = [231]\n",
    "p_hat2 = phat(coef_arr,test2_x)\n",
    "odds2 = p_hat2/(1-p_hat2)\n",
    "print(\"odds for \",test2_x, \"are:\", odds2, \"to 1 or\", Fraction(odds2),\"to 1\")\n",
    "\n",
    "odds_ratio =  odds2 / odds\n",
    "print(\"odds ratio is\", odds_ratio)\n",
    "print(\"Another way of calculating the odds ratio is from the coefficients\")\n",
    "print(\"By putting our coefficients to the power of e or\",np.exp(1),\"we get the odds ratio:\")\n",
    "print((np.exp(result.params)))\n",
    "\n",
    "print(\"So the odds of \", odds_ratio,\"holds true for any 1 unit increase for any credit score.\")\n",
    "print(\"If you had a score of 380 and increased to 381 it would have the same odds ratio.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "line_x = [i for i in range(100,400)]\n",
    "line_y = [phat(coef_arr,[x]) for x in range(100,400)]\n",
    "plot(line_x,line_y, x_credit_scores,y_zeroes_and_ones,800, 400, \n",
    "     \"Credit score\",\"Percentages\",\"Credit Scores of \" + str(sample_size) + \" individuals on a scatter plot\",\n",
    "    True, True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## <span style=\"color:black\">Multiple Logistic Regression:</span>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* What is the probability for Olaf getting a loan with:\n",
    "    * credit_score = 250.\n",
    "    * loan_amount = 20000000\n",
    "    * age = 80\n",
    "    * marital = 0\n",
    "    * health_insurance = 0\n",
    "    \n",
    "We have to:\n",
    "1. Read the loans.csv file\n",
    "2. Only get the columns we will be using. \n",
    "    * we can use df.loc[:,('col1','col2','col3')] or slicing into another variable.\n",
    "3. Calculate the coefficients\n",
    "4. Are there any risk factors for not getting a loan ?\n",
    "5. Calculate the probability of Olaf getting a loan\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the data in\n",
    "dfm = pd.read_csv(\"F:\\Recourse\\Logistic-Regression-master\\Logistic-Regression-master\\loans.csv\")\n",
    "\n",
    "\n",
    "# All the columns\n",
    "'''accepted,creditscore,amount,age,marital,health_ins,creditgrade'''\n",
    "# Get only columns we want\n",
    "dfm = dfm.loc[:,('accepted','creditscore','amount','age','marital','health_ins')]\n",
    "'''accepted,creditscore,amount,age,marital,health_ins'''\n",
    "\n",
    "print(dfm.head(), '\\n')\n",
    "print (dfm.describe(), '\\n')\n",
    "print (\"Std deviation:\",dfm.std())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Frequency tables and histograms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Frequency tables for our binary data \n",
    "# print(pd.crosstab(dfm['accepted'],dfm['age'], rownames=['accepted or not']))\n",
    "print(pd.crosstab(dfm['accepted'],dfm['marital'],rownames=['accepted or not']))\n",
    "print(pd.crosstab(dfm['accepted'],dfm['health_ins'], rownames=['accepted or not']))\n",
    "\n",
    "# Make histograms from the data\n",
    "dfm.hist()\n",
    "pl.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dfm['intercept'] = 1.00\n",
    "\n",
    "m_train_cols = dfm.columns[1:]\n",
    "print(m_train_cols)\n",
    "\n",
    "# the Logit uses the Newton optimizer in Maximum Likelihood Estimation (MLE), \n",
    "# (see print(result.mle_settings) )\n",
    "\n",
    "m_logit = sm.Logit(dfm['accepted'], dfm[m_train_cols])\n",
    "\n",
    "result = m_logit.fit()\n",
    "coef_arr_2 = result.params.values\n",
    "#print(result.resid_generalized)\n",
    "print(result.summary())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "'''Olafs info\n",
    "credit_score = 250,\n",
    "loan_amount = 20000000,\n",
    "age = 80,\n",
    "marital = 0,\n",
    "health_insurance = 0,\n",
    "'''\n",
    "olafs_info = [250,20000000,80,0,0]\n",
    "\n",
    "olaf_phat = phat(coef_arr_2,olafs_info)\n",
    "print(\"With a credit score of:\", olafs_info[0])\n",
    "print(\"loan amount of:\", olafs_info[1])\n",
    "print(\"age:\",olafs_info[2])\n",
    "print(\"marital status:\",olafs_info[3])\n",
    "print(\"and health insurance:\",olafs_info[4])\n",
    "print(\"Olaf has an estimated probabilty of\", \"%0.2f\" % (olaf_phat*100), \"% to get a loan.\" )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "If the probability of getting a loan is p then not getting a loan would be q = 1 - p\n",
    "\n",
    "**To sum it up the LR model is all about solving for p based on the values of the independent variables**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Olaf has an estimated probabilty of\", \"%0.2f\" % ((1-olaf_phat)*100), \"% of NOT getting a loan.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color:black;\"> Appendix 1</span>\n",
    "### <span style=\"color:black;\">Generation code for loan data:</span>\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/usr/bin/env python3\n",
    "import sys\n",
    "import os\n",
    "from random import randint\n",
    "from math import ceil\n",
    "from datetime import datetime\n",
    "\n",
    "# Config Variables\n",
    "'''Remove the loans.csv file'''\n",
    "# % rm loans.csv # Comment this line if you are not running this in jupyter notebook\n",
    "               # or know what you are doing. Currently this does not support partial data\n",
    "                # we have a read_file function that needs work and other components need some work\n",
    "\n",
    "\n",
    "loan_info_file = \"F:\\Recourse\\Logistic-Regression-master\\Logistic-Regression-master\\loans.csv\"\n",
    "if os.path.exists(loan_info_file):\n",
    "    os.remove(loan_info_file)\n",
    "    print(\"removed old\", loan_info_file)\n",
    "\n",
    "lines_for_each_part = 3000\n",
    "#------ \n",
    "# Constants\n",
    "''' parts is constant 5 because credit score grades are in 5 parts'''\n",
    "parts = 5\n",
    "\n",
    "\n",
    "def is_not_zero_file(fpath):\n",
    "    return os.path.isfile(fpath) and os.path.getsize(fpath) > 0\n",
    "\n",
    "def read_file(ppl):\n",
    "    with open(loan_info_file, 'r') as f:\n",
    "        for l in f.read().split('\\n')[1:]:\n",
    "            l = l.strip()\n",
    "            if not l:\n",
    "                continue\n",
    "            l = l.split(',')\n",
    "            per = {}\n",
    "            per['accepted'] = l[0]\n",
    "            if len(l) > 1:\n",
    "                per['creditscore'] = l[1]\n",
    "                per['amount'] = l[2]\n",
    "                per['age'] = l[3]\n",
    "                per['marital'] = l[4]\n",
    "            \n",
    "            ppl.append(per)\n",
    "\n",
    "def create_new(ppl):\n",
    "\n",
    "    # Try to generate evenly distributed 0 and 1 for accepted/not accepted:\n",
    "    '''\n",
    "    To help us do that we will be using\n",
    "    The Credit Info credit grade that are mapped unto the points defined as follows\n",
    "    A = 353-400+, \n",
    "    B = 317-353, \n",
    "    C = 281-317, \n",
    "    D = 235-281, \n",
    "    E = 100-235\n",
    "\n",
    "    E and D applicants do not get a loan unless it is very small or dep on other factors.\n",
    "    \n",
    "    Within grades they also define subgrades that this program does not implement:\n",
    "    A1 A2 A3 B1 B2 B3 C1 C2 C3 D1 D2 D3 E1 E2 E3\n",
    "    '''\n",
    "    \n",
    "    A,B,C,D,E = 0,1,2,3,4\n",
    "    \n",
    "    for i in range(0,parts):\n",
    "        for j in range(ceil(i * lines_for_each_part),  ceil((i+1) * lines_for_each_part)):\n",
    "            \n",
    "            per = {}\n",
    "\n",
    "            if i == A:\n",
    "                if randint(0,18) == 1:\n",
    "                    # Maybe some random people dont get a loan in A\n",
    "                    per['accepted'] = 0\n",
    "                else:\n",
    "                    per['accepted'] = 1\n",
    "                per['health_ins'] = randint(0,1)\n",
    "                per['creditscore'] = randint(353,400)\n",
    "                per['creditgrade'] = 'A'\n",
    "            elif i == B:\n",
    "                if randint(0,7) == 1:\n",
    "                    # Maybe some random people dont get a loan in B\n",
    "                    per['accepted'] = 0\n",
    "                    per['health_ins'] = randint(0,1)\n",
    "                    \n",
    "                else:\n",
    "                    per['accepted'] = 1\n",
    "                    per['health_ins'] = 1\n",
    "                \n",
    "                per['creditscore'] = randint(317,353)\n",
    "                per['creditgrade'] = 'B'\n",
    "\n",
    "            elif i == C: \n",
    "                n = randint(0,1)\n",
    "                per['accepted'] = n\n",
    "                per['health_ins'] = n\n",
    "                per['creditscore'] = randint(281,317)\n",
    "                \n",
    "                per['creditgrade'] = 'C'\n",
    "\n",
    "            elif i == D:\n",
    "                if randint(0,3) == 1:\n",
    "                    per['accepted'] = 1\n",
    "                    per['health_ins'] = 1\n",
    "                else:\n",
    "                    per['accepted'] = 0\n",
    "                    per['health_ins'] = 0\n",
    "                \n",
    "                per['creditscore'] = randint(235,281)\n",
    "                per['creditgrade'] = 'D'\n",
    "\n",
    "            elif i == E:\n",
    "                if randint(0,40) == 1:\n",
    "                    # Maybe some random people in E get a loan\n",
    "                    per['accepted'] = 1\n",
    "                    per['health_ins'] = 1\n",
    "                else:\n",
    "                    per['accepted'] = 0\n",
    "                    per['health_ins'] = 0\n",
    "                per['creditscore'] = randint(100,235)\n",
    "\n",
    "                per['creditgrade'] = 'E'\n",
    "            \n",
    "            ppl.append(per)\n",
    "\n",
    "\n",
    "def gen_age(per):\n",
    "    if per['accepted'] == 1:\n",
    "        return randint(18, 90)\n",
    "    elif per['creditgrade'] == 'E':\n",
    "        return randint(55,90)\n",
    "    elif per['creditgrade'] == 'D':\n",
    "        if randint(0,4) == 2:\n",
    "            return randint(18,30)\n",
    "        return randint(55,90)\n",
    "    else:\n",
    "        return randint(18, 90)\n",
    "\n",
    "def gen_marital(per):\n",
    "    if per['age'] > 78:\n",
    "        return 0\n",
    "    if per['accepted'] == 1:\n",
    "        if randint(0,6) == 3:\n",
    "            return 0\n",
    "        else:\n",
    "            return 1\n",
    "    if per['accepted'] == 0:\n",
    "        if randint(0,2) == 1:\n",
    "            return 1\n",
    "        else:\n",
    "            return 0\n",
    "\n",
    "def gen_cscore(per):\n",
    "    '''We will be basing the credit score the risk factor \n",
    "    The Credit Info Risk Factor Grade that are defined as follows\n",
    "    A = 353-400+ points, B 317-353 points, C = 281-317, D = 235-281, E = 100-235'''\n",
    "    if['creditgrade'] == 'A':\n",
    "        return randint(353,400)\n",
    "    if['creditgrade'] == 'B':\n",
    "        return randint(317,352)\n",
    "    if['creditgrade'] == 'C':\n",
    "        return randint(281,316)\n",
    "    if['creditgrade'] == 'D':\n",
    "        return randint(235,280)\n",
    "    if['creditgrade'] == 'E':\n",
    "        return randint(100,235)\n",
    "def gen_amount(per):\n",
    "    if per['accepted'] == 1:\n",
    "        if per['age'] > 50 or per['age'] < 25:\n",
    "            # Small loan half mil to 10 mil\n",
    "            return randint(500000,15000000)\n",
    "        if per['creditgrade'] == 'E':\n",
    "            # Small loan\n",
    "            return randint(100000,6000000)\n",
    "        else:\n",
    "            # Possibly bigger loan\n",
    "            return randint(1000000,70000000)\n",
    "    else:\n",
    "        return randint(1000000,100000000)    \n",
    "\n",
    "def add_to_file(ppl):\n",
    "    with open(loan_info_file, 'w') as f:\n",
    "        f.write('accepted,creditscore,amount,age,marital,health_ins,creditgrade\\n')\n",
    "        # Here you can sort the file by other things if you want\n",
    "        for per in sorted(ppl, key=lambda x: x['accepted']):\n",
    "            f.write('%s,%s,%s,%s,%s,%s,%s\\n' % (per['accepted'], per['creditscore'], per['amount'],per['age'],per['marital'],per['health_ins'],per['creditgrade']))\n",
    "\n",
    "def main():\n",
    "    # This list will store a dict for each line\n",
    "    ppl = []\n",
    "    \n",
    "    if is_not_zero_file(loan_info_file):\n",
    "        print(\"reading old file...\")\n",
    "        read_file(ppl)\n",
    "    \n",
    "    if not ppl:\n",
    "        create_new(ppl)\n",
    "        \n",
    "    for per in ppl:\n",
    "        '''This is the order in which we will determine each factor\n",
    "        create_new() handles accepted, creditgrade, health_ins and creditscore'''\n",
    "\n",
    "        if 'age' not in per:\n",
    "            per['age'] = gen_age(per)\n",
    "        if 'marital' not in per:\n",
    "            per['marital'] = gen_marital(per)\n",
    "        if 'creditscore' not in per:\n",
    "            per['creditscore'] = gen_cscore()\n",
    "        if 'amount' not in per:\n",
    "            per['amount'] = gen_amount(per)\n",
    "    \n",
    "    add_to_file(ppl)\n",
    "    print(\"Length of new file\", loan_info_file, \"is:\" , len(ppl))\n",
    "    print(\"Last created at\" ,str(datetime.now()))\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}