diff --git a/NOTICE b/NOTICE index 547595f..4851a73 100644 --- a/NOTICE +++ b/NOTICE @@ -4,9 +4,6 @@ All Rights Reserved. Licensed under the LinkedIn Learning Exercise File License (the "License"). See LICENSE in the project root for license information. -ATTRIBUTIONS: -[PLEASE PROVIDE ATTRIBUTIONS OR DELETE THIS AND THE ABOVE LINE “ATTRIBUTIONS”] - Please note, this project may automatically load third party code from external repositories (for example, NPM modules, Composer packages, or other dependencies). If so, such third party code may be subject to other license terms than as set diff --git a/README.md b/README.md index 95d74e5..c0f1fbc 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,10 @@ -# Machine Learning with Python: Logistic Regeression -This is the repository for the LinkedIn Learning course `Machine Learning with Python: Logistic Regeression`. The full course is available from [LinkedIn Learning][lil-course-url]. +# Machine Learning with Python: Logistic Regression +This is the repository for the LinkedIn Learning course Machine Learning with Python: Logistic Regression. The full course is available from [LinkedIn Learning][lil-course-url]. + +![1666987773227](https://user-images.githubusercontent.com/25848438/200744832-b3c06517-af4a-4dea-9131-fc05d33e866f.jpeg) + +Are you looking for a practical way to use machine learning to solve complex real-world problems? Logistic regression is an approach to supervised machine learning that models selected values to predict possible outcomes. In this course, Notre Dame professor Frederick Nwanganga provides you with a step-by-step guide on how to build a logistic regression model using Python. Learn hands-on tips for collecting, exploring, and transforming your data before you even get started. By the end of this course, you’ll have the technical skills to know when and how to design, build, evaluate, and effectively manage a logistic regression model all on your own.

This course is integrated with GitHub Codespaces, an instant cloud developer environment that offers all the functionality of your favorite IDE without the need for any local machine setup. With GitHub Codespaces, you can get hands-on practice from any machine, at any time—all while using a tool that you’ll likely encounter in the workplace. Check out the [Using GitHub Codespaces with this course][gcs-video-url] video to learn how to get started. -_See the readme file in the main branch for updated instructions and information._ ## Instructions This repository has branches for each of the videos in the course. You can use the branch pop up menu in github to switch to a specific branch and take a look at the course at that stage, or you can add `/tree/BRANCH_NAME` to the URL to go to the branch you want to access. @@ -20,15 +23,12 @@ To resolve this issue: Add changes to git using this command: git add . Commit changes using this command: git commit -m "some message" -## Installing -1. To use these exercise files, you must have the following installed: - - [list of requirements for course] -2. Clone this repository into your local machine using the terminal (Mac), CMD (Windows), or a GUI tool like SourceTree. -3. [Course-specific instructions] +### Instructor +Frederick Nwanganga -[0]: # (Replace these placeholder URLs with actual course URLs) +Check out my other courses on [LinkedIn Learning](https://www.linkedin.com/learning/instructors/frederick-nwanganga?u=104). -[lil-course-url]: https://www.linkedin.com/learning/ -[lil-thumbnail-url]: http:// +[lil-course-url]: https://www.linkedin.com/learning/machine-learning-with-python-logistic-regression +[gcs-video-url]: https://www.linkedin.com/learning/machine-learning-with-python-logistic-regression/using-github-codespaces-with-this-course diff --git a/src/03b.ipynb b/src/03b.ipynb new file mode 100644 index 0000000..9b9fb7c --- /dev/null +++ b/src/03b.ipynb @@ -0,0 +1,557 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "11963cc7", + "metadata": {}, + "source": [ + "# Classifying Data with Logistic Regression in Python\n", + "\n", + "## Learning Objectives\n", + "Logistic Regression is one of the simplest and most commonly used classification approaches in machine learning. Logistic regression allows us to model the relationship between independent variables and the probability of a categorical response (such as True or False, Yes or No). By the end of this tutorial, you will have learned:\n", + "\n", + "+ How to import, explore and prepare data\n", + "+ How to build a Logistic Regression model\n", + "+ How to evaluate a Logistic Regression model\n", + "+ How to interpret the coefficients of a Logistic Regression model " + ] + }, + { + "cell_type": "markdown", + "id": "2887bb87", + "metadata": {}, + "source": [ + "## 1. Collect the Data" + ] + }, + { + "cell_type": "markdown", + "id": "7c96c17b", + "metadata": {}, + "source": [ + "Before we import our data, we must first import the `pandas` package." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "de4b4a56", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "id": "eff3ec92", + "metadata": {}, + "source": [ + "Now, we can import our data into a dataframe called `loan`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "b53e3b3f", + "metadata": {}, + "outputs": [], + "source": [ + "loan = pd.read_csv(\"loan.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c190dc61", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IncomeLoan AmountDefault
0308No
12210No
23312No
32820No
42332No
\n", + "
" + ], + "text/plain": [ + " Income Loan Amount Default\n", + "0 30 8 No\n", + "1 22 10 No\n", + "2 33 12 No\n", + "3 28 20 No\n", + "4 23 32 No" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loan.head()" + ] + }, + { + "cell_type": "markdown", + "id": "836693c2", + "metadata": {}, + "source": [ + "To verify that the import worked as expected, let’s use the `head()` method of the pandas dataframe to preview the data." + ] + }, + { + "cell_type": "markdown", + "id": "758f2183", + "metadata": {}, + "source": [ + "Our dataset has three columns. The first two - `Income` and `Loan Amount` - are the predictors (or independent variables), while the last one - `Default` - is the response (or dependent variable).\n", + "\n", + "In this exercise, we’ll use this `loan` data to train a logistic regression model to predict whether a borrower will default or not default on a new loan based on their income and the amount of money they intend to borrow. " + ] + }, + { + "cell_type": "markdown", + "id": "e6095cae", + "metadata": {}, + "source": [ + "## 2. Explore the Data" + ] + }, + { + "cell_type": "markdown", + "id": "c1c66cc1", + "metadata": {}, + "source": [ + "Now that we have our data, let's try to understand it.\n", + "\n", + "First, let's get a concise summary of the structure of the data by calling the `info()` method of the `loan` dataframe." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "67de73e2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 30 entries, 0 to 29\n", + "Data columns (total 3 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Income 30 non-null int64 \n", + " 1 Loan Amount 30 non-null int64 \n", + " 2 Default 30 non-null object\n", + "dtypes: int64(2), object(1)\n", + "memory usage: 852.0+ bytes\n" + ] + } + ], + "source": [ + "loan.info()" + ] + }, + { + "cell_type": "markdown", + "id": "b7f146df", + "metadata": {}, + "source": [ + "By looking at the `RangeIndex` value from the summary, we can tell that there are 30 instances (or rows) in the dataset. \n", + "\n", + "The `Data columns` value shows that the dataset consists of 3 features (or columns). Looking at the `Dtype` column within this section, we see that the `Income` and `Loan Amount` columns hold integer values, while the `Default` column holds text (aka object)." + ] + }, + { + "cell_type": "markdown", + "id": "c4602524", + "metadata": {}, + "source": [ + "Next, let's get summary statistics for the numeric features in the data by calling the `describe()` method of the dataframe." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "acdf6ca5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
IncomeLoan Amount
count30.00000030.000000
mean20.96666754.233333
std6.19501128.231412
min12.0000008.000000
25%16.25000032.000000
50%20.50000054.500000
75%24.75000071.750000
max34.000000110.000000
\n", + "
" + ], + "text/plain": [ + " Income Loan Amount\n", + "count 30.000000 30.000000\n", + "mean 20.966667 54.233333\n", + "std 6.195011 28.231412\n", + "min 12.000000 8.000000\n", + "25% 16.250000 32.000000\n", + "50% 20.500000 54.500000\n", + "75% 24.750000 71.750000\n", + "max 34.000000 110.000000" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "loan.describe()" + ] + }, + { + "cell_type": "markdown", + "id": "8889a842", + "metadata": {}, + "source": [ + "From the statistics, we can see the average, standard deviation, minimum, and maximum values for both the `Income` and `Loan Amount` variables. We also get the 25th, 50th and 75th percentile values for both variables.\n", + "\n", + "Note that the values are in the thousands, so the minimum and maximum income values are \\\\$12,000 and \\\\$34,000, respectively. \n", + "\n", + "Now that we've described our data structurally and numerically, let’s describe it visually as well." + ] + }, + { + "cell_type": "markdown", + "id": "1ed89ece", + "metadata": {}, + "source": [ + "### Boxplot\n", + "Before we create the plots we need, we must first import a couple of packages. The first is the `matplotlib` package and the second is the `seaborn` package." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7239372b", + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "markdown", + "id": "5013146d", + "metadata": {}, + "source": [ + "Let's start by creating a boxplot that highlights the difference in annual income between those that did not default on their loan (No) and those that did default (Yes). " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "9308d55a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = sns.boxplot(data = loan,x= 'Default',y='Income',hue = 'Default')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6da0bae9", + "metadata": {}, + "source": [ + "The chart shows that those that did not default on their loans tend to have a higher annual income than those that did default on their loans. " + ] + }, + { + "cell_type": "markdown", + "id": "fd1574a4", + "metadata": {}, + "source": [ + "Next, let's create another box plot to highlight the difference in amount borrowed between those that did not default on their loans and those that did." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "bcb7b490", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = sns.boxplot(data =loan,x ='Default',y ='Loan Amount',hue = 'Default')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "7158408e", + "metadata": {}, + "source": [ + "This chart shows that those that defaulted on their loans tend to have borrowed more money than those that did not default." + ] + }, + { + "cell_type": "markdown", + "id": "9e51544a", + "metadata": {}, + "source": [ + "### Scatterplot\n", + "If we recode the `Default` feature values 'No' and 'Yes' to '0' and '1', we can also use a scatterplot to get a slightly different perspective of our data. " + ] + }, + { + "cell_type": "markdown", + "id": "bbdc98b1", + "metadata": {}, + "source": [ + "However, before we do so, we must first import the `numpy` package." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "04b9e4bd", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "88188d4c", + "metadata": {}, + "source": [ + "Now, we can create a scatterplot that describes the relationship between the annual income of borrowers and loan outcomes. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "f0e2438f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = sns.scatterplot(x = loan['Income'],\n", + " y = np.where(loan['Default'] == 'No',0,1),\n", + " s = 100)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "dbcc993e", + "metadata": {}, + "source": [ + "We can also describe the relationship between the amount borrowed and loan outcomes. " + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "1387c926", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ax = sns.scatterplot(x = loan['Loan Amount'],\n", + " y = np.where(loan['Default'] == 'No',0,1),\n", + " s = 100)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5b063af6", + "metadata": {}, + "source": [ + "Looking at these two charts, we can easily imagine a sigmoid curve that fits the data. This tells us that a logistic regression function would model the relationship between the predictors (`Income` and `Loan Amount`) and the response (`Default`) well." + ] + } + ], + "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.12.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/03e.ipynb b/src/03e.ipynb new file mode 100644 index 0000000..19ec61b --- /dev/null +++ b/src/03e.ipynb @@ -0,0 +1,330 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "11963cc7", + "metadata": {}, + "source": [ + "# Classifying Data with Logistic Regression in Python\n", + "\n", + "## Learning Objectives\n", + "Logistic Regression is one of the simplest and most commonly used classification approaches in machine learning. Logistic regression allows us to model the relationship between independent variables and the probability of a categorical response (such as True or False, Yes or No). By the end of this tutorial, you will have learned:\n", + "\n", + "+ How to import, explore and prepare data\n", + "+ How to build a Logistic Regression model\n", + "+ How to evaluate a Logistic Regression model\n", + "+ How to interpret the coefficients of a Logistic Regression model " + ] + }, + { + "cell_type": "markdown", + "id": "2887bb87", + "metadata": {}, + "source": [ + "## 1. Collect the Data" + ] + }, + { + "cell_type": "markdown", + "id": "7c96c17b", + "metadata": {}, + "source": [ + "Before we import our data, we must first import the `pandas` package." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de4b4a56", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd" + ] + }, + { + "cell_type": "markdown", + "id": "eff3ec92", + "metadata": {}, + "source": [ + "Now, we can import our data into a dataframe called `loan`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b53e3b3f", + "metadata": {}, + "outputs": [], + "source": [ + "loan = pd.read_csv(\"loan.csv\")" + ] + }, + { + "cell_type": "markdown", + "id": "836693c2", + "metadata": {}, + "source": [ + "To verify that the import worked as expected, let’s use the `head()` method of the pandas dataframe to preview the data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "046f5901", + "metadata": {}, + "outputs": [], + "source": [ + "loan.head()" + ] + }, + { + "cell_type": "markdown", + "id": "758f2183", + "metadata": {}, + "source": [ + "Our dataset has three columns. The first two - `Income` and `Loan Amount` - are the predictors (or independent variables), while the last one - `Default` - is the response (or dependent variable).\n", + "\n", + "In this exercise, we’ll use this `loan` data to train a logistic regression model to predict whether a borrower will default or not default on a new loan based on their income and the amount of money they intend to borrow. " + ] + }, + { + "cell_type": "markdown", + "id": "e6095cae", + "metadata": {}, + "source": [ + "## 2. Explore the Data" + ] + }, + { + "cell_type": "markdown", + "id": "c1c66cc1", + "metadata": {}, + "source": [ + "Now that we have our data, let's try to understand it.\n", + "\n", + "First, let's get a concise summary of the structure of the data by calling the `info()` method of the `loan` dataframe." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "67de73e2", + "metadata": {}, + "outputs": [], + "source": [ + "loan.info()" + ] + }, + { + "cell_type": "markdown", + "id": "b7f146df", + "metadata": {}, + "source": [ + "By looking at the `RangeIndex` value from the summary, we can tell that there are 30 instances (or rows) in the dataset. \n", + "\n", + "The `Data columns` value shows that the dataset consists of 3 features (or columns). Looking at the `Dtype` column within this section, we see that the `Income` and `Loan Amount` columns hold integer values, while the `Default` column holds text (aka object)." + ] + }, + { + "cell_type": "markdown", + "id": "c4602524", + "metadata": {}, + "source": [ + "Next, let's get summary statistics for the numeric features in the data by calling the `describe()` method of the dataframe." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "acdf6ca5", + "metadata": {}, + "outputs": [], + "source": [ + "loan.describe()" + ] + }, + { + "cell_type": "markdown", + "id": "8889a842", + "metadata": {}, + "source": [ + "From the statistics, we can see the average, standard deviation, minimum, and maximum values for both the `Income` and `Loan Amount` variables. We also get the 25th, 50th and 75th percentile values for both variables.\n", + "\n", + "Note that the values are in the thousands, so the minimum and maximum income values are \\\\$12,000 and \\\\$34,000, respectively. \n", + "\n", + "Now that we've described our data structurally and numerically, let’s describe it visually as well." + ] + }, + { + "cell_type": "markdown", + "id": "1ed89ece", + "metadata": {}, + "source": [ + "### Boxplot\n", + "Before we create the plots we need, we must first import a couple of packages. The first is the `matplotlib` package and the second is the `seaborn` package." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7239372b", + "metadata": {}, + "outputs": [], + "source": [ + "from matplotlib import pyplot as plt\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "markdown", + "id": "5013146d", + "metadata": {}, + "source": [ + "Let's start by creating a boxplot that highlights the difference in annual income between those that did not default on their loan (No) and those that did default (Yes). " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9308d55a", + "metadata": {}, + "outputs": [], + "source": [ + "ax = sns.boxplot(data = loan, x = 'Default', y = 'Income')" + ] + }, + { + "cell_type": "markdown", + "id": "6da0bae9", + "metadata": {}, + "source": [ + "The chart shows that those that did not default on their loans tend to have a higher annual income than those that did default on their loans. " + ] + }, + { + "cell_type": "markdown", + "id": "fd1574a4", + "metadata": {}, + "source": [ + "Next, let's create another box plot to highlight the difference in amount borrowed between those that did not default on their loans and those that did." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bcb7b490", + "metadata": {}, + "outputs": [], + "source": [ + "ax = sns.boxplot(data = loan, x = 'Default', y = 'Loan Amount')" + ] + }, + { + "cell_type": "markdown", + "id": "7158408e", + "metadata": {}, + "source": [ + "This chart shows that those that defaulted on their loans tend to have borrowed more money than those that did not default." + ] + }, + { + "cell_type": "markdown", + "id": "9e51544a", + "metadata": {}, + "source": [ + "### Scatterplot\n", + "If we recode the `Default` feature values 'No' and 'Yes' to '0' and '1', we can also use a scatterplot to get a slightly different perspective of our data. " + ] + }, + { + "cell_type": "markdown", + "id": "bbdc98b1", + "metadata": {}, + "source": [ + "However, before we do so, we must first import the `numpy` package." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "04b9e4bd", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "88188d4c", + "metadata": {}, + "source": [ + "Now, we can create a scatterplot that describes the relationship between the annual income of borrowers and loan outcomes. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f0e2438f", + "metadata": {}, + "outputs": [], + "source": [ + "ax = sns.scatterplot(x = loan['Income'], \n", + " y = np.where(loan['Default'] == 'No', 0, 1), \n", + " s = 150)" + ] + }, + { + "cell_type": "markdown", + "id": "dbcc993e", + "metadata": {}, + "source": [ + "We can also describe the relationship between the amount borrowed and loan outcomes. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1387c926", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "ax = sns.scatterplot(x = loan['Loan Amount'], \n", + " y = np.where(loan['Default'] == 'No', 0, 1), \n", + " s = 150)" + ] + }, + { + "cell_type": "markdown", + "id": "5b063af6", + "metadata": {}, + "source": [ + "Looking at these two charts, we can easily imagine a sigmoid curve that fits the data. This tells us that a logistic regression function would model the relationship between the predictors (`Income` and `Loan Amount`) and the response (`Default`) well." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/loan.csv b/src/loan.csv new file mode 100644 index 0000000..721c5f9 --- /dev/null +++ b/src/loan.csv @@ -0,0 +1,31 @@ +Income,Loan Amount,Default +30,8,No +22,10,No +33,12,No +28,20,No +23,32,No +34,32,No +23,35,No +26,38,No +30,50,No +26,70,No +23,45,No +24,32,No +18,24,No +25,32,No +17,63,Yes +12,71,Yes +24,62,Yes +19,40,Yes +18,68,Yes +13,54,Yes +13,55,Yes +15,58,Yes +18,72,Yes +17,76,Yes +13,78,Yes +15,85,Yes +18,90,Yes +16,100,Yes +22,105,Yes +14,110,Yes \ No newline at end of file