From 1b493823ae06c37eb2b13a02aa3fc2f6a535c703 Mon Sep 17 00:00:00 2001 From: noah Date: Tue, 7 Mar 2023 12:49:39 -0600 Subject: [PATCH] Logistic Regression for problem 10.3 Mowers --- Schrick-Noah_Learning-Practice-6.ipynb | 234 ++++++++++++++++++++++++- 1 file changed, 228 insertions(+), 6 deletions(-) diff --git a/Schrick-Noah_Learning-Practice-6.ipynb b/Schrick-Noah_Learning-Practice-6.ipynb index 27cd3a6..42f5d5d 100644 --- a/Schrick-Noah_Learning-Practice-6.ipynb +++ b/Schrick-Noah_Learning-Practice-6.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -10,7 +10,21 @@ "# Logistic Regression for Classification\n", "# # Professor: Dr. Abdulrashid, Spring 2023\n", "# Noah L. Schrick - 1492657\n", - "\n" + "\n", + "%matplotlib inline\n", + "\n", + "from pathlib import Path\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn.linear_model import LogisticRegression, LogisticRegressionCV\n", + "from sklearn.model_selection import train_test_split\n", + "import statsmodels.api as sm\n", + "from mord import LogisticIT\n", + "import matplotlib.pylab as plt\n", + "import seaborn as sns\n", + "from dmba import classificationSummary, gainsChart, liftChart\n", + "from dmba.metric import AIC_score" ] }, { @@ -35,10 +49,204 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Owner 50.0\n", + "Nonowner 50.0\n", + "Name: Ownership, dtype: float64\n" + ] + } + ], + "source": [ + "mowers_df = pd.read_csv('RidingMowers.csv')\n", + "\n", + "# a\n", + "owner_pctg = mowers_df['Ownership'].value_counts(normalize=True) * 100\n", + "print(owner_pctg)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ownership\n", + "Nonowner 57.400\n", + "Owner 79.475\n", + "Name: Income, dtype: float64\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# b \n", + "mowers_df.plot.scatter(x='Lot_Size', y='Income', legend=True)\n", + "owner_inc = mowers_df.groupby('Ownership')['Income'].mean()\n", + "print(owner_inc)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Classified Correctly: 80.0 %\n", + " actual p(0) p(1) predicted\n", + "13 Nonowner 0.418583 0.581417 Owner\n", + "14 Nonowner 0.838644 0.161356 Nonowner\n", + "17 Nonowner 0.936463 0.063537 Nonowner\n", + "18 Nonowner 0.958456 0.041544 Nonowner\n", + "20 Nonowner 0.979416 0.020584 Nonowner\n" + ] + } + ], + "source": [ + "# c\n", + "predictors = ['Lot_Size', 'Income']\n", + "outcome = 'Ownership'\n", + "\n", + "X = pd.get_dummies(mowers_df[predictors], drop_first=True)\n", + "y = mowers_df[outcome]\n", + "classes = ['Owner', 'Nonowner']\n", + "\n", + "# split into training and validation\n", + "train_X, valid_X, train_y, valid_y = train_test_split(X, y, test_size=0.25, \n", + " random_state=1)\n", + "\n", + "logit_full = LogisticRegression(penalty=\"l2\", C=1e42, solver='liblinear')\n", + "logit_full.fit(train_X, train_y)\n", + "\n", + "logit_reg_pred = logit_full.predict_proba(valid_X)\n", + "full_result = pd.DataFrame({'actual': valid_y, \n", + " 'p(0)': [p[0] for p in logit_reg_pred],\n", + " 'p(1)': [p[1] for p in logit_reg_pred],\n", + " 'predicted': logit_full.predict(valid_X)})\n", + "full_result = full_result.sort_values(by=['p(1)'], ascending=False)\n", + "\n", + "subset_df = full_result.loc[full_result['actual'] == 'Nonowner']\n", + "\n", + "num_corr = 0\n", + "total = 0\n", + "for index, row in subset_df.iterrows(): \n", + " if (row['actual'] == row['predicted']):\n", + " num_corr += 1\n", + " total += 1\n", + " else:\n", + " total += 1\n", + "\n", + "print(\"Classified Correctly:\", num_corr/total*100.00, \"%\")\n", + "print(subset_df)\n", + "\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# d\n", + "Cutoff percentage should be decreased." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Odds of event: 1.7719334017055501\n" + ] + } + ], + "source": [ + "# e\n", + "data = [[20, 60]]\n", + "pred = pd.DataFrame(data, columns=['Lot_Size', 'Income'])\n", + "\n", + "logit_reg_pred_s = logit_full.predict_proba(pred)\n", + "p0 = [p[0] for p in logit_reg_pred_s]\n", + "p1 = [p[1] for p in logit_reg_pred_s]\n", + "full_result = pd.DataFrame({'p(0)': p0,\n", + " 'p(1)': p1,\n", + " 'predicted': logit_full.predict(pred)})\n", + "print(\"Odds of event:\", np.exp(p1[0]))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Nonowner\n" + ] + } + ], + "source": [ + "# f\n", + "print(full_result)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "94.9000000000068\n" + ] + } + ], + "source": [ + "# g. What is the minimum income that a household with 16,000 ft2 lot size should have before it is classified as an owner? \n", + "init = 60\n", + "while(True):\n", + " data = [[16, init]]\n", + " pred = pd.DataFrame(data, columns=['Lot_Size', 'Income'])\n", + "\n", + " logit_reg_pred_s = logit_full.predict_proba(pred)\n", + " p0 = [p[0] for p in logit_reg_pred_s]\n", + " p1 = [p[1] for p in logit_reg_pred_s]\n", + " full_result = pd.DataFrame({'p(0)': p0,\n", + " 'p(1)': p1,\n", + " 'predicted': logit_full.predict(pred)})\n", + " if(full_result['predicted'][0] == 'Nonowner'):\n", + " init = init + 0.025\n", + " else:\n", + " print(init)\n", + " break\n" + ] }, { "attachments": {}, @@ -69,8 +277,22 @@ } ], "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, "language_info": { - "name": "python" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" }, "orig_nbformat": 4 },