From 910bcf9cbdf3bf6590fdadc467799c1ffedd97e9 Mon Sep 17 00:00:00 2001 From: Dangote Date: Mon, 20 Apr 2020 11:07:12 +0100 Subject: [PATCH 1/4] Added challenge folder by Jato Joseph --- .../notebook-checkpoint.ipynb | 501 +++++++++++++ JatoJoseph_Logistic/Admittance.csv | 169 +++++ JatoJoseph_Logistic/notebook.ipynb | 702 ++++++++++++++++++ 3 files changed, 1372 insertions(+) create mode 100644 JatoJoseph_Logistic/.ipynb_checkpoints/notebook-checkpoint.ipynb create mode 100644 JatoJoseph_Logistic/Admittance.csv create mode 100644 JatoJoseph_Logistic/notebook.ipynb diff --git a/JatoJoseph_Logistic/.ipynb_checkpoints/notebook-checkpoint.ipynb b/JatoJoseph_Logistic/.ipynb_checkpoints/notebook-checkpoint.ipynb new file mode 100644 index 0000000..c480400 --- /dev/null +++ b/JatoJoseph_Logistic/.ipynb_checkpoints/notebook-checkpoint.ipynb @@ -0,0 +1,501 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "logistic_challenge.ipynb", + "provenance": [], + "collapsed_sections": [], + "toc_visible": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "code", + "metadata": { + "id": "x0ovbaMbHuju", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MpvDLTrhHyiC", + "colab_type": "text" + }, + "source": [ + "## Outline:\n", + "* Define a logistic regression\n", + "* State and explain the formula and it's variables\n", + "* Get a dataset\n", + "* Build a logistic function and explain its effect \n", + "* Train the model\n", + "* Test the model\n", + "* Interprete the Logistic Regression \n", + "Table\n", + "* Summary\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KMnIsHxQW5wU", + "colab_type": "text" + }, + "source": [ + "## Logistic Regression\n", + "Logistic regression is a statistical model that in its basic form uses a logistic function to model a binary dependent variable.The possible outcomes of a logistic regression are not numerical but\n", + "rather categorical ( 1 or 0, Yes or No ) etc.\n", + "\n", + "Even though a Logistic regression is seen as a generalized linear model, It is a linear model with a link function that maps the output of linear multiple regression to a posterior probability of each class (0,1) using the **logistic\n", + "sigmoid function.**\n", + "\n", + "## The Logistic Regression Formla\n", + "\n", + "\n", + "## $p(X)/1 −p (X) = e ( β 0 +β 1 X 1 +...+β k X k )$\n", + "\n", + "Where,\n", + "\n", + "$p(X)$ = Probability of the dsitribution\n", + "\n", + "$e$ = Exponent\n", + "\n", + "$β0β1$ = Coefficients\n", + "\n", + "$X1$ = Independenet variable\n", + "\n", + "## **ODDS** = $p (X)/1 −p (X)$\n", + "\n", + "The logistic regression model is not very useful in itself. The right-hand side of the model is an exponent which is very computationally inefficient and generally hard to grasp.\n", + "\n", + "When we talk about a *logistic regression* what we usually mean is **logit regression** – which is a variation of the model where we have taken the log of both sides. See formula below:\n", + "\n", + "## $log(p(X)/1 −p(X)) = log(e(β 0 + β 1 x + ⋯ β k x k))$\n", + "\n", + "On the right hand side, log cancels 'e(exponential)' function leavig us with our new formula:\n", + "\n", + "## $log(p(X)/1 −p(X)) = β 0 + β 1 x + ⋯ β k x k$\n", + "\n", + "With odds:\n", + "\n", + "## $log (odds) = β 0 + β 1 x + ⋯ β k x k$\n", + "\n", + "We'll implemt all these in the code section of the project.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "81EgDyl4xjiK", + "colab_type": "text" + }, + "source": [ + "## The Dataset\n", + "Our dataset will be a collection of jamb scores of students that sat for the 2020 Utme Jamb in March.\n", + "## Task\n", + "We build a logistic model that tells us the probaliity of a student getting admission based on their jamb scores." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "t2-v-b3k6vCP", + "colab_type": "text" + }, + "source": [ + "## Code Implementation" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "pAQNMn8cIf25", + "colab_type": "code", + "outputId": "7ba9593c-afc0-4f62-caf2-2a9fb9da4117", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 72 + } + }, + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import statsmodels.api as sm\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "sns.set()" + ], + "execution_count": 0, + "outputs": [ + { + "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": "markdown", + "metadata": { + "id": "Cd5voKSS7Iqt", + "colab_type": "text" + }, + "source": [ + "## DATA" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "hSgCe0RA67oM", + "colab_type": "code", + "colab": {} + }, + "source": [ + "data = pd.read_csv('/content/jamb_scores.csv')" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "a19Zmvij7Xsq", + "colab_type": "code", + "outputId": "48457280-76a6-4120-b4f8-960735b35e4d", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + } + }, + "source": [ + "data.head()" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "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", + "
ScoresAdmitted
02551
11050
22211
33591
43001
\n", + "
" + ], + "text/plain": [ + " Scores Admitted\n", + "0 255 1\n", + "1 105 0\n", + "2 221 1\n", + "3 359 1\n", + "4 300 1" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 3 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JUTJfJIdGoQj", + "colab_type": "text" + }, + "source": [ + "Observe that those that scored from 180 and above are assigned an admitted value of 1 indicated their possiblity of getting admission.\n", + "\n", + "Let's seee what our regression model will tell us" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QotmOvecHI36", + "colab_type": "text" + }, + "source": [ + "## Variables" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "H-g8QnRSGA3O", + "colab_type": "code", + "colab": {} + }, + "source": [ + "X = data['Scores'] # Independent variable\n", + "y = data['Admitted'] # Dependent variable" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dI1ejw-7HiDB", + "colab_type": "text" + }, + "source": [ + "## PLOT\n", + "\n", + "Let's plot the data to see its distribution before building our logistic function" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ut5XnF8wHT4q", + "colab_type": "code", + "outputId": "715529c5-69cc-45d5-e27a-76e20154d7b9", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 291 + } + }, + "source": [ + "# Create a scatter plot of x (Scores) and y (Admitted)\n", + "plt.scatter(X,y, color='C0')\n", + "plt.xlabel('Scores', fontsize = 20)\n", + "plt.ylabel('Admitted', fontsize = 20)\n", + "plt.show()" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAESCAYAAAAFYll6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3de5gdVZnv8e/enaSJuRBoO4RAEjCaNyEHTKLAgECIynARBideIAoBGXCYMw+O91FGkOg4MsLoGcbwgDpoRMlRMYoPBjODA8FoVJBELpIXTiQECSFNcwlBCKS7zx+rdlK9e99WZ3fv6t2/z/P0s3uvWlX1rqre++2qVbUq19PTg4iISIx8owMQEZGhR8lDRESiKXmIiEg0JQ8REYmm5CEiItFGNDqAQdAKHAk8CXQ1OBYRkaGiBTgQuBvYWTxxOCSPI4FfNDoIEZEh6nhgTXHhcEgeTwI8++yLdHfH39PS1jaWzs4ddQ9qsDVDO9SGbGiGNkBztGMg25DP59hvvzGQfIcWGw7Jowugu7unX8mjMG8zaIZ2qA3Z0AxtgOZoxyC0oeTpfnWYi4hINCUPERGJpuQhIiLRGtrnYWZXA+8CDgEOd/cHStRpAa4BTgF6gCvd/RuDGaeIiPTW6A7zHwP/TuVLad8PvB54A9AGrDOz291908CHJ8PZ2ge3smL1Rjq376RtfCtHTG/jvo2dvd7fvWEbO17aBcCYfVp430kGsHu+saNH0NPTw4sv9+5znDBmJM+/+Crprs7JbaN5x7GH8u2fPcTOV8OUHHDi3Mmce/LMPrEtv/3hPus+Zvakim26avm9PPTYc7vft+ThgnccVnW+9PZ4ZvtO9h/fysL50/l/f3qO1eu30N0D+RzMn9M31lLbcuH86RXXma6f3oZt41uZuN9ofPNzu9dpUyfw+LYdvbbFUbMO6LWvCuu7cdUG7li3pde6JowZyfY/v0qpfufWkTkWnzKrZKzpGPM56O6hprbduGpDTdssdtsVL9emTmDbsy/VvM1j5bIwJLuZbQJOL3Pk8VPgm+5+c/L+q8Bj7n5VjYs/BHi0s3NHv65KaG8fR0fHC9HzZU0ztGMw27D2wa0su20Dr+zqjpovlwvngrvq/LFakEogax/cyjdXPsSuopW05OCC08snguLEkXbRGZUTSKntkc/l6C7x/bGgKNmVmnfUiDznnTqz7Jdyf7Z9JaNG5Jl+0Piy7a8kl4MLi7ZrpRgrta1U8oK+26zSetLLL3wmyi231rhKyedztLWNBTgU2NRnek1LaaypwGOp95uBKQ2KRYaJFas39uvLq6en/okDYPX6PV8MK1Zv7JM4IKx3xeqNZZdR6Yuz0nyF6cXbo1TiKI613Lyv7Oouu87+bvtKXtnV3a/EAWGfFsdaKcZKbSveNtXKa9125eavNa7+aPRpq0GTZNB+aW8fV8dIGqcZ2jFYbXhme5/RGBqqu2dP2yvF9sz2nf3aRtXmi9ke6VgrzVtunVnb9tA31moxlmtbuZMfxdus2nrSy29vH1d2ubXG1R9DIXlsBqYRxleBvkciNdFpq6HfjsFsw/7jW+nM0JdYPsfutleKbf/xrf3aRtXmi9ke6VgrzVtunVnb9tA31moxlmtboW+kVHnMtigsv/CZKLfcWuMqJXXaqvT0mpbSWD8ALjKzvJm1A+8Ebm5wTNLkFs6fzqgR8R+PXC70PdTb/DmTd/++cP50RpRYSUsuTCtn1rQJZadVmq8wvXh75HOlG5qOtdy8o0bky66zv9u+klEj8hXbX0muxHatFGOlthVvm2rltW67cvPXGld/NDR5mNk1ZvYn4GDgdjN7MClfaWZvTqrdCPwReAT4NfA5d3+0IQHLsHHM7Emcd+pM2sa3AuEqmgVzJ/d5P3b0noP3Mfu0cOHph3HB6Yftrjd29AjG7NPSZ/kTxoyk+Kt3cttoLjrjMFpH7pmSo29n6jGzJ/GB02b1WXelznKATyya1+cLtCVfvbO8eHvkkvb/zemzWDB3Mvkk3HyudMdvqW1ZqeO2uH56G7aNb2XWtAm91jlr2oQ+26J4X5136kw+sWgeC+b2/ZKdMGbk7uUVax2Z69NZXirGwvzV2nbuyTNr2mbl1lNu+aWWO2vahJq3eX9k4mqrAXYIutqqKdqhNmRDM7QBmqMdA9mGZrjaSkREMkbJQ0REoil5iIhINCUPERGJpuQhIiLRlDxERCSakoeIiERT8hARkWhKHiIiEk3JQ0REoil5iIhINCUPERGJpuQhIiLRlDxERCSakoeIiERT8hARkWhKHiIiEk3JQ0REoil5iIhINCUPERGJpuQhIiLRlDxERCSakoeIiERT8hARkWhKHiIiEk3JQ0REoil5iIhINCUPERGJpuQhIiLRlDxERCSakoeIiEQb0egAzGwGsAxoAzqBxe7+SFGdicA3gSnASOAO4EPuvmuQwxUREbJx5HEdsNTdZwBLgetL1LkUeMjdjwCOAN4ELBy8EEVEJK2hySM5opgHLE+KlgPzzKy9qGoPMM7M8kArMAp4YtACFRGRXhp92moK8IS7dwG4e5eZbUnKO1L1Pg/8EHgSGAN81d1/GbOitrax/Q6yvX1cv+fNkmZoh9qQDc3QBmiOdjSqDY1OHrV6D3Af8DZgHHCbmb3b3W+udQGdnTvo7u6JXnF7+zg6Ol6Ini9rmqEdakM2NEMboDnaMZBtyOdzFf/pbnSfx+PAQWbWApC8Tk7K0y4Bvuvu3e7+PHALsGBQIxURkd0amjzcfRuwHliUFC0C1rl7R1HVR4FTAMxsFPB24IHBilNERHpr9JEHwMXAJWb2MOEI42IAM1tpZm9O6nwYON7M7ickm4eBrzciWBERyUCfh7tvAI4uUX5a6veNwEmDGZeIiJSXhSMPEREZYpQ8REQkmpKHiIhEU/IQEZFoSh4iIhJNyUNERKIpeYiISDQlDxERiabkISIi0ZQ8REQkmpKHiIhEKzu2lZlN7e9C3X1zf+cVEZHsqzQw4ibC419j9VRZroiIDHGVvuS/Td/kcShwAvA8YWj0rcAkYA6wL3AX4dkbIiLSxMomD3c/P/3ezAxYC3wFWOLu21PTxgNLgMXABwckUhERyYyY00tXAve7+8eKJySJ5CNm9qak3sI6xSciIhkUc7XVCcCaKnXWAPP7H46IiAwFMcmjldC/UcmBST0REWliMcljHXC2mc0tNTE5ZXUWcG89AhMRkeyK6fNYAvwM+LWZfZdwZdVTwAGEU1XvIySjJfUOUkREsqXm5OHut5vZ2cD1wPnAeanJOeBZ4IPu/vO6RigiIpkTdTOfu99sZrcBZwLzCPd2PE84VXWLu79Y/xBFRCRrou8ETxLETcmPiIgMQ/0eGNHM9jOzKfUMRkREhoaoIw8zG0voEH8/0E5qHCszOxr4LPAZd9cVVyIiTazmIw8z25cwPMlHgC3AQ4SO8oL7geOBRfUMUEREsifmtNU/AbOB8919HvCD9ER3/zOwGnhb/cITEZEsikkeC4FV7v7tCnUeAw7au5BERCTrYpLHwcB9VersIFy+KyIiTSwmebwATKxS51Dg6f6HIyIiQ0HM1VZ3A6eb2Th3f6F4opkdCJwG3BoTgJnNAJYBbUAnsNjdHylR773AZYRO+h7g7e7+VMy6RESkPmKOPP6d8AW/0sxmpSck738A7ANcExnDdcBSd58BLCUMf9KLmb0ZuAI4yd3/F3Ac4c52ERFpgJqTh7uvItzj8RbgAeDTAGb2dPL+WODT7v6rWpdpZhMJw5wsT4qWA/PMrL2o6keAq919axLL8+7+cq3rERGR+oq6w9zdlxAuxf0JYSDELsIppJWE00hXRa5/CvCEu3cly+8i3ENSfOf6YcDrzOwuM7vXzD5jZjlERKQh+jO21R3AHQMQSyUtwBHAScAowtDwm4FKlw330tY2tt8rb28f1+95s6QZ2qE2ZEMztAGaox2NakPNycPMFgPr3b3s5bpmdjgwt8q9IGmPAweZWYu7d5lZCzA5KU/bDNzs7juBnWZ2C3AUEcmjs3MH3d09tVbfrb19HB0dfa4PGHKaoR1qQzY0QxugOdoxkG3I53MV/+mOOW31LeCdVer8FfDNWhfo7tuA9ewZ0mQRsM7dO4qq3gT8pZnlzGwk4dTZ72tdj4iI1Fe/R9Uto4XQBxLjYuASM3sYuCR5j5mtTK6yAvi/wDbgD4Rk8yDwn3WJWEREokX3eVQxg9CRXjN33wAcXaL8tNTv3cBHkx8REWmwisnDzG4oKnqnmR1SomoLMJUwqu5P6xOaiIhkVbUjj/NTv/cAc5KfUnqA3xDuyRARkSZWLXkcmrzmgD8C/4dwp3mxLuBZPcNcRGR4qJg83P2xwu9mtgS4I10mIiLDU8zVVlWvojKz483s8r2IR0REhoCY5HEFcGKVOicQnmMuIiJNrN73eYwEuuu8TBERyZh6J4956GFQIiJNr9p9Hv9TVHS+mZ1YomoLYSTcaewZXl1ERJpUtUt1T0z93gMckvwU6yY8BfB76D4PEZGmV+1S3d2ntcysG7jC3T834FGJiEimxYxt9QFg3UAFIiIiQ0fNycPdlw1kICIiMnSUTR5mdkLy62/d/eXU+6rc/a69jkxERDKr0pHHnYRO8lnAw6n3tWjZq6hERCTTKiWPzxGSxdNF70VEZJgrmzzc/YpK70VEZPiq9x3mIiIyDCh5iIhItKhnmJvZwYQ7yOcABxMGQizW4+7T6xCbiIhkVM3JIxnTaiWwD7ALeCp5LZarS2QiIpJZMUceXyJcgrsYuMndNfS6iMgwFZM8DgeWu/t3BioYEREZGmI6zJ8FnhmoQEREZOiISR63AvMHKhARERk6YpLHpcC+ZrbUzMYMVEAiIpJ9MaPqPm1mpwC/ARab2cPA8yWq9rj72+oVoIiIZE/MpbqzgTuA/ZKiuWWqavwrEZEmF3O11ZeBNuByYBmwxd27BiQqERHJtJjkcQywwt3/eaCCERGRoSGmw/wVYNMAxSEiIkNIzJHHncBR9Q7AzGYQToO1AZ3AYnd/pExdIzxH/Vp3/3i9YxERkdrEHHl8EjjMzD5lZvUcv+o6YKm7zwCWAteXqmRmLcm0H9dx3SIi0g8xRx6fAR4AvgBcZGbrKX+p7t/UskAzmwjMA05KipYDXzWzdnfvKKr+KcKNimOTHxERaZCY5HF+6vdDk59SeoCakgcwBXiicNWWu3eZ2ZakfHfyMLM3AicDC4DLImLera2t//mmvX1cv+fNkmZoh9qQDc3QBmiOdjSqDTHJo1yyGFBmNhL4GvCBJLn0azmdnTvo7o6/BaW9fRwdHS/0a51Z0gztUBuyoRnaAM3RjoFsQz6fq/hPd8wd5o/VJaLeHgcOMrOWJDG0AJOT8oIDgenAyiRxTAByZjbe3T84ADGJiEgVUU8SrDd335b0nSwCvpO8rkv3d7j7ZuC1hfdmdgUwVldbiYg0TtnkYWZT+7vQ5Au/VhcDy8zscsKw74uT9a8ELnf3e/obh4iIDIxKRx6b6N84VT1VltuLu28Aji5RflqZ+lf0IyYREamjSl/y36Zv8jgUOIFwie56YCswCZgD7AvcBTxa/zBFRCRLyiYPdz8//T65u3st8BVgibtvT00bDywhnHJSJ7aISJOL6TC/Erjf3T9WPCFJJB8xszcl9RbWKT4REcmgmOFJTgDWVKmzBj2qVkSk6cUkj1ZC/0YlByb1RESkicUkj3XA2WZW8gmCySmrs4B76xGYiIhkV0yfxxLgZ8Cvzey7hCurngIOIJyqeh8hGS2pd5AiIpItMfdj3G5mZxOGRT8fOC81OUe4we+D7v7zukYoIiKZE3PaCne/GZgKnEO4ZPeG5PWcpPxHZnZmvYMUEZFsiR7byt1fBG5KfgAws2mE5218gNBp3lKvAEVEJHv6PTBiMgLumYSbAt9OOIrpAW6vT2giIpJV0cnDzF4HXETo95iYFD9N6Av5zwEaul1ERDKkpuRhZiOAvyYcZSwgHGW8AqwA3gXc4u6XD1SQIiKSLRWTh5m9gXCUcR7hmRo54HfAt4Cb3P1ZM+se6CBFRCRbqh15OKEf4yngy8C33P3BAY9KREQyrZZLdXuA24AfKnGIiAhUTx6XAZsJl+D+0sz+YGafNLMDBz40ERHJqorJw92/4O6vA04FfgRMJwy5vtnMfmpm7x2EGEVEJGNqusPc3Ve5+7uBKcClwGOEhLKccFprTjIwooiIDAOxw5Nsc/cr3f31wEnAzcCrwJuB35rZOjP7+wGIU0REMiQqeaS5+8/d/SzgYOCTwCPAG4Fr6hSbiIhkVL+HJylw96eBq4GrzexE4MK9XaaIiGTbXiePNHe/E7iznssUEZHs6fdpKxERGb6UPEREJJqSh4iIRFPyEBGRaEoeIiISTclDRESiKXmIiEi0ut7n0R9mNgNYBrQBncBid3+kqM5lwNlAF2E4lEvdfdVgxyoiIkEWjjyuA5a6+wxgKeFZ6MV+Cxzp7kcAFwDfM7PRgxijiIikNDR5mNlEYB5hdF6S13lm1p6ul4zq++fk7X2Ex+G2DVqgIiLSS6OPPKYAT7h7F0DyuiUpL2cxsNHd/zQI8YmISAkN7/OIYWbzgc8ThoOP0tY2tt/rbW8f1+95s6QZ2qE2ZEMztAGaox2NakOjk8fjwEFm1uLuXWbWAkxOynsxs2OA7wBnurvHrqizcwfd3T3RAba3j6Oj44Xo+bKmGdqhNmRDM7QBmqMdA9mGfD5X8Z/uhp62cvdtwHpgUVK0CFjn7h3pemZ2JPA94N3ufu/gRikiIsUafeQBcDGwzMwuB54l9GlgZiuBy939HuBaYDRwvZkV5jvX3e9vQLwiIsNew5OHu28Aji5Rflrq9yMHNSgREamo0VdbiYjIEKTkISIi0ZQ8REQkmpKHiIhEU/IQEZFoSh4iIhJNyUNERKIpeYiISDQlDxERiabkISIi0ZQ8REQkmpKHiIhEU/IQEZFoSh4iIhJNyUNERKIpeYiISDQlDxERiabkISIi0ZQ8REQkmpKHiIhEU/IQEZFoSh4iIhJNyUNERKIpeYiISDQlDxERiabkISIi0ZQ8REQkmpKHiIhEU/IQEZFoSh4iIhJNyUNERKKNaHQAZjYDWAa0AZ3AYnd/pKhOC3ANcArQA1zp7t8YyLjWPriVFas38sz2new/vpWF86dzzOxJA7nKmt24agOr12+huwfyOZg/ZzLnnjyzT5071m3pM+/IFni1a8/7WdMm8IlF80ou8/UHT2DF6o10bt/JmH1ayOVy7HhpF22p7VHYTp3bd1Ysn7jfaHzzcxVjXvvgVm76b+fFl/cEOGafFo6adQD3bezcvS+OmN7G3Ru2seOlXbvrvO8kY819W3josed6LbN1ZI6dr/aU3ZajR+VZ+tETd6+/EHNBuVhFhrtcT0/5D9ZgMLP/AW5w9++Y2TnABe7+1qI6i4H3A6cSksw64Dh331TDKg4BHu3s3EF3d21tXfvgVpbdtoFXdnXvLhs1Is95p85seAIplxQWzN3zBVeuTjkTxozkuRdf7VOey0G5P49RI/K85fBJ/PL+rX22U6nyUtIxr31wKzfc+ge6GvDnOHpUnnNOntlnn6elY90b7e3j6Oh4Ya+X00jN0AZojnYMZBvy+RxtbWMBDgU29Zk+IGutkZlNBOYBy5Oi5cA8M2svqnoW8HV373b3DuDHwHsGKq4Vqzf2+RJ5ZVc3K1ZvHKhV1mz1+tJJIV1erk45pRIHlE8cELbH6vVbSm6nUuWlpONcsXpjQxIHwEuvdJfc52mx21Sk2TX6tNUU4Al37wJw9y4z25KUd6TqTQUeS73fnNSpWZJBa/JM6rRFcXl7+7iY1dZduYOn7h52x1bjAdaAxlLr/IWYy23zwVJt/elY91aj/4bqoRnaAM3Rjka1odHJY9DEnLbaf3xrr/Pe6fJGH+bmc6W/nPM5dsdWrs5gxlLL+tMxl9vmg6Xa+tOx7g2dKsmOZmjHIJ22Kj19QNZau8eBg5IO8ULH+OSkPG0zMC31fmqJOnWzcP50Ro3ovWlGjcizcP70gVplzebPmVy1vFydciaMGVmyPJcrP8+oEXnmz5lccjuVKi8lHefC+dNpqbC+gTR6VL7kPk+L3aYiza6hycPdtwHrgUVJ0SJgXdKvkfYD4CIzyyf9Ie8Ebh6ouI6ZPYnzTp1J2/hWckDb+NZMdJYDnHvyTBbMnUw++aLN5/p25hbqlDKypff7WdMm8OVLji+5zAtPP4y28a1AuKJp7OhwoFrYHueePHP3dqpWPmvahIoxHzN7Ehecfhhj9ukd4Jh9Wlgwd3KvfbFg7uTdsRTqXHTGYcyaNqFPe1tHVs5Ihaut0vs8rVSsIpKNq61mEi7V3Q94lnCprpvZSuByd78nOSL5KvCXyWz/6u5fq3EVhxB5tVVaMxzaQnO0Q23IhmZoAzRHOxp5tVXD+zzcfQNwdIny01K/dwF/N5hxiYhIeY3u8xARkSFIyUNERKIpeYiISLSG93kMghYInT/9tTfzZkkztENtyIZmaAM0RzsGqg2p5baUmt7wq60GwXHALxodhIjIEHU8sKa4cDgkj1bgSOBJoKtKXRERCVqAA4G7gT7DLwyH5CEiInWmDnMREYmm5CEiItGUPEREJJqSh4iIRFPyEBGRaEoeIiISTclDRESiDYfhSWpmZpuAl5MfgH9091Vm9hfA9cBowrj25yQPsmo4M7saeBfhuSWHu/sDSfkMwnNS2oBOwnNSHqk2rVEqtGMTJfZJMi0z+8XM2oAbgenAK8AjwN+6e0elOLPUhiSeSu3oAe4HupPq57r7/cl8ZwBXEb5Tfgd8wN3/PNjxF5jZjwnPoegGdgCXuPv6ofS5qNCGTWTgM6Ejj77e7e5zkp9VZpYHvgP8vbvPAO4CrmxsiL38GDgBeKyo/DpgaRLzUsIfVC3TGqVcO6BonwBkcL/0AF9yd3P3w4GNwJWV4sxgG6BMO1LTj03ti0LiGAt8HTjD3V8PvAB8fLADL3Keu7/R3ecCVwM3JOVD6XNRrg2Qgc+Ekkd1bwJedvfC2C7XAe9tYDy9uPsad+/1PHczmwjMA5YnRcuBeWbWXmnaYMVcSql2VJGp/eLuz7j7namiXwPTqBxnptoAFdtRyanAPan/0q8DzhqA8Grm7s+n3u4LdA+1z0WpNlSZZVD/npQ8+vqumd1nZtea2QRgKqn/ht39aSBvZvs3LMLqpgBPJE9gLDyJcUtSXmlaVhXvE8jwfkn+A/w74CdUjjOzbYA+7Si408zWm9kXzazwwPde7QA2k4G/JzP7hpltBr4AnMcQ/FyUaENBwz8TSh69He/ubyQMpJgjPDddGmso7pP/IJyjHgqxVlLcjqnu/mbC6cXDgMsaFVgt3P1Cd58KXErojxlyyrQhE58JJY+UwmkTd98JXAu8hfBf1O7DdjN7LdDt7s80JMjaPA4cZGYtAMnr5KS80rTMKbNPIKP7Jen4fwNwlrt3UznOTLYhiaW4Hel9sR34BmX2BeE/4Mz8Pbn7jcAC4E8M0c9FoQ1m1paVz4SSR8LMxpjZvsnvOeBsYD3hypHRZnZcUvVi4AeNibI2ydUV64FFSdEiYJ27d1SaNviRVlZhn0AG94uZ/QvhvPM7kw82VI4zc22A0u0ws/3MbHTy+wjg3ezZFz8DjjSzNyTvLwa+P7hR72FmY81sSur9GcAzwJD5XFRow8tZ+UxoSPaEmb0O+CFhDPsW4A/Ah9z9STM7lnDlxT7sufztqUbFmmZm1wALgUnA00Cnu882s5mEyw73A54lXHboyTxlpzVKqXYAZ1BmnyTzZGa/mNls4AHgYeClpPhRd//rSnFmqQ1JPCXbAXyJEGcPMBL4FfBhd9+RzHdmUqcFWAec7+4vDm70gZkdANwCjCE8w+cZ4OPufu9Q+VyUawPwHBn5TCh5iIhINJ22EhGRaEoeIiISTclDRESiKXmIiEg0JQ8REYmm5CEiItE0JLsIu+8ovgA4BzgcGEe41n8r8FvgJ+7+k/JLEBlelDxk2EsSx63AKYSbsH5KGMpiFDAbeB8wk94DBIoMa0oeImEoilOA3wPzi4bCxsxeAxzdiMBEskrJQwSOTV6/VZw4AJIn4t1RXG5mZwEfBOYCryGc4loL/Ju735Oq1wp8BHg/4Ql9uwiJ6j/c/ftFyzyEMBzIMuBfgM8TBvV7LfDWwrM2zOxk4B+Aowin2P4ErAC+4O7PFS3zCODTwDHAgcB2woB/dwGfcPdXq28ikd6UPETCOFoAM2qpnAxI903C8xWeJnxpdwAHE77oHbgnqTsKWAXMBzYQnlD3GsLAgt8zsznufmmJ1UwHfkMYY+q7hMeKbk+W+VngCsJ4R7cSBvw7gjD20Wlmdkwy8m0hcfyGMCbVTwiJaTzweuB/A58BlDwkmpKHSPjy/0fgYjMbB/wI+J27l3okLsBFhMRxN3BS+mgl6T+ZmKr7MULiuA34K3ffldRbQuiI/7SZ3eruvypax3HAF4sTi5ktICSOtcBp6aMMMzufkNSWEI50SOLchzBC7i1Fy9oPaNhzxmVo06W6Muy5+zrCVVZPJa8/BDaZWaeZ/SgZDjvtkuT1b4tPc7l7V2GE08QFhP/6P1pIHEm9bYRTUgAXlgjrKUISKPah5PWi4tNT7v4twvDc7y8x30vFBe7+bOFZHSKxNKquSMLMRhJOOx1H6Mc4Dig84vPbwPmEU047gKfcfVKV5Y0jnGp6wt0PLjH9UOCPwHp3n5uUHUI4tfRf7n5yiXm2AvsT+kNKeQ/hKX+vdfdOMzuKMHz6K8DNwO3AL919Y6XYRarRaSuRRNJx/F/JT+EU1LuAG4DFhNNZdyfVn6hhkfsmr0+WmV4on1Bi2tYy87QRPrefrbLusYRnu/zWzI4H/onQz3IugJk5sMTdl1dZjkhJSh4iZbh7F/B9Mzuc0LH8VuC/k8kH1bCIwimtckcoBxbVSyt3SuB5IO/u+9ewfgDcfS1wenLV15sIlyVfAtxkZh3ufnutyxIpUJ+HSHUvJK+55Ol4DwAHmNncSjO5+wvARsKzsd9QosqC5PXeiFh+DeyXPPEvirvvdPdfufvl7Ok7OTN2OSKg5CGCmTuFc0gAAAF7SURBVC0ys5PMrM/nwcwmEa6ugnBfBMA1yev1hedJp+rnzezAVNENQA64KjkNVqj3WuCyVJ1afSV5/bqZTS4R7xgz+4vU+2MLzx4vckDyqqutpF902kok3D3+D8BWM1tD6LAGOBR4B+Eei1sIHc4A3wCOJ/QfPGJmtxDu85hMOLV1A+FyWoCrgVMJ/+H/3sxWEjrd30O4pPdL7r6m1kDd/edm9ingi8m6VybxjgWmES4LXkM4NQXwSeCtZvaLpN4OwpArpxLG7vparesWSVPyEIF/Ax4B3k642e5kwr0RncCdwE3ATe7eA5C8LjazVYQ7zN8LtBI6wH9Bagwsd3/FzE4CPkoYI+sS9txh/uH+dFi7+7+a2S8Jp56OIySm5wmd+F9L4i24lpAkjk7qjiDcjX4t4U74cveyiFSkS3VFRCSa+jxERCSakoeIiERT8hARkWhKHiIiEk3JQ0REoil5iIhINCUPERGJpuQhIiLRlDxERCSakoeIiET7/yqy1Zqdm1Y/AAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "imqAD27oP0Lc", + "colab_type": "text" + }, + "source": [ + "## Logistic formula\n", + "\n", + "Let's covert the logistic regressio formula to a python function" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "hBt-pNzZPzju", + "colab_type": "code", + "colab": {} + }, + "source": [ + "def log_form(x,b0,b1):\n", + " return np.array(np.exp(b0+x*b1) / (1 + np.exp(b0+x*b1)))" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "i2Jjeo3aRhW1", + "colab_type": "text" + }, + "source": [ + "## The Logit Function\n", + "\n", + "Here, we are going to call the Logit function from statsmodel and fit it on our data" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ibAxdnqQRlZ6", + "colab_type": "code", + "colab": {} + }, + "source": [ + "x_const = sm.add_constant(X)\n", + "reg_log = sm.Logit(y,X)\n", + "results = reg_log.fit()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RxTjA2XAA1b6", + "colab_type": "text" + }, + "source": [ + "## Logistic Summary" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "2UlPlAfKA5mc", + "colab_type": "code", + "colab": {} + }, + "source": [ + "results.summary()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XmToMDMpSY_5", + "colab_type": "text" + }, + "source": [ + "## Sorting" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "VFfBEWX_SdVD", + "colab_type": "code", + "outputId": "a67d5992-3259-470c-aeae-807c383473bc", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 748 + } + }, + "source": [ + "f_sorted = np.sort(log_form(X,results_log.params[0],results_log.params[1]))\n", + "x_sorted = np.sort(np.array(X))" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "error", + "ename": "IndexError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_value\u001b[0;34m(self, series, key)\u001b[0m\n\u001b[1;32m 4403\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 4404\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_value\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtz\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgetattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseries\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\"tz\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4405\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_value\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_value\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 1", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mf_sorted\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlog_form\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mresults_log\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mresults_log\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mparams\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mx_sorted\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msort\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/pandas/core/series.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 869\u001b[0m \u001b[0mkey\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcom\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply_if_callable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 870\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 871\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_value\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 872\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 873\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mis_scalar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/usr/local/lib/python3.6/dist-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_value\u001b[0;34m(self, series, key)\u001b[0m\n\u001b[1;32m 4408\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4409\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 4410\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mlibindex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_value_at\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 4411\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mIndexError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4412\u001b[0m \u001b[0;32mraise\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.get_value_at\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.get_value_at\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/util.pxd\u001b[0m in \u001b[0;36mpandas._libs.util.get_value_at\u001b[0;34m()\u001b[0m\n", + "\u001b[0;32mpandas/_libs/util.pxd\u001b[0m in \u001b[0;36mpandas._libs.util.validate_indexer\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mIndexError\u001b[0m: index out of bounds" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CKuWoq7YN_a7", + "colab_type": "text" + }, + "source": [ + "## Plot a Logistic Curve\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "SUjjHHh_H7QO", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/JatoJoseph_Logistic/Admittance.csv b/JatoJoseph_Logistic/Admittance.csv new file mode 100644 index 0000000..5910743 --- /dev/null +++ b/JatoJoseph_Logistic/Admittance.csv @@ -0,0 +1,169 @@ +Score,Admitted +1363,No +1792,Yes +1954,Yes +1653,No +1593,No +1755,Yes +1775,Yes +1887,Yes +1893,Yes +1580,No +1857,Yes +1880,Yes +1664,Yes +1364,No +1693,No +1850,Yes +1633,No +1634,No +1636,Yes +1855,Yes +1987,Yes +1997,Yes +1422,No +1508,No +1720,Yes +1879,Yes +1634,Yes +1802,Yes +1849,Yes +1764,Yes +1460,No +1675,Yes +1656,No +2020,Yes +1850,Yes +1865,Yes +1664,No +1872,Yes +1654,No +1393,No +1587,No +1631,Yes +1931,Yes +1370,No +1810,Yes +1414,No +1761,Yes +1477,No +1486,No +1561,No +1549,No +2050,Yes +1697,No +1543,No +1934,Yes +1385,No +1670,No +1735,Yes +1634,No +1777,Yes +1550,No +1715,Yes +1925,Yes +1842,Yes +1786,Yes +1435,No +1387,No +1521,No +1975,Yes +1435,No +1714,Yes +1634,Yes +1464,No +1794,Yes +1855,Yes +1953,Yes +1469,No +1663,Yes +1907,Yes +1990,Yes +1542,No +1808,Yes +1966,Yes +1679,No +2021,Yes +2015,Yes +1473,No +1979,Yes +1787,Yes +1687,Yes +1674,No +1478,No +1735,Yes +1720,Yes +1494,No +1964,Yes +1843,Yes +1550,No +1764,Yes +1712,Yes +1775,Yes +1531,No +1781,Yes +1579,No +1526,No +1778,Yes +1769,Yes +1824,Yes +1481,No +1464,No +1591,No +1666,No +1455,No +1934,Yes +1625,No +1334,No +1721,Yes +1475,No +1662,Yes +1861,Yes +1936,Yes +1572,No +1508,No +1430,No +1891,Yes +1550,No +1741,Yes +1690,No +1687,Yes +1730,Yes +1674,Yes +1475,No +1962,Yes +1532,No +1492,No +1502,No +1974,Yes +1607,No +1412,No +1557,No +1821,Yes +1760,Yes +1685,Yes +1773,Yes +1826,Yes +1565,No +1510,No +1374,No +1402,No +1702,Yes +1956,Yes +1933,Yes +1832,Yes +1893,Yes +1831,Yes +1487,No +2041,Yes +1850,Yes +1555,No +2020,Yes +1593,No +1934,Yes +1808,Yes +1722,Yes +1750,Yes +1555,No +1524,No +1461,No diff --git a/JatoJoseph_Logistic/notebook.ipynb b/JatoJoseph_Logistic/notebook.ipynb new file mode 100644 index 0000000..9c2dec9 --- /dev/null +++ b/JatoJoseph_Logistic/notebook.ipynb @@ -0,0 +1,702 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "MpvDLTrhHyiC" + }, + "source": [ + "## Outline:\n", + "* Define a logistic regression\n", + "* State and explain the formula and it's variables\n", + "* Get a dataset\n", + "* Build a logistic function and explain its effect \n", + "* Train the model\n", + "* Test the model\n", + "* Interprete the Logistic Regression \n", + "Table\n", + "* Summary\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "KMnIsHxQW5wU" + }, + "source": [ + "## Logistic Regression\n", + "Logistic regression is a statistical model that in its basic form uses a logistic function to model a binary dependent variable.The possible outcomes of a logistic regression are not numerical but\n", + "rather categorical ( 1 or 0, Yes or No ) etc.\n", + "\n", + "Even though a Logistic regression is seen as a generalized linear model, It is a linear model with a link function that maps the output of linear multiple regression to a posterior probability of each class (0,1) using the **logistic\n", + "sigmoid function.**\n", + "\n", + "## The Logistic Regression Formla\n", + "\n", + "\n", + "## $p(X)/1 −p (X) = e ( β 0 +β 1 X 1 +...+β k X k )$\n", + "\n", + "Where,\n", + "\n", + "$p(X)$ = Probability of the dsitribution\n", + "\n", + "$e$ = Base of the Natural Log\n", + "\n", + "$β0$ = Biase or Intercept\n", + "\n", + "$β1$ = Coefficient\n", + "\n", + "$X1$ = Independenet variable\n", + "\n", + "## **ODDS** = $p (X)/1 −p (X)$\n", + "\n", + "The logistic regression model is not very useful in itself. The right-hand side of the model is an exponent which is very computationally inefficient and generally hard to grasp.\n", + "\n", + "When we talk about a *logistic regression* what we usually mean is **logit regression** – which is a variation of the model where we have taken the log of both sides. See formula below:\n", + "\n", + "## $log(p(X)/1 −p(X)) = log(e(β 0 + β 1 x + ⋯ β k x k))$\n", + "\n", + "On the right hand side, log cancels 'e(exponential)' function leavig us with our new formula:\n", + "\n", + "## $log(p(X)/1 −p(X)) = β 0 + β 1 x + ⋯ β k x k$\n", + "\n", + "With odds:\n", + "\n", + "## $log (odds) = β 0 + β 1 x + ⋯ β k x k$\n", + "\n", + "We'll implemt all these in the code section of the project.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "t2-v-b3k6vCP" + }, + "source": [ + "## Code Implementation" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 72 + }, + "colab_type": "code", + "id": "pAQNMn8cIf25", + "outputId": "7ba9593c-afc0-4f62-caf2-2a9fb9da4117" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import statsmodels.api as sm\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "sns.set()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "Cd5voKSS7Iqt" + }, + "source": [ + "## DATA\n", + "\n", + "Our dataset is not a real life data, it was made for the purpose of this challenge. \n", + "We ain to predict whether a stuent will get admitted based on the cummulative points of students in their secondary school courses.\n", + "\n", + "The bench mark is 1700 points for a student to get admitted and anything short of that will not be admitted." + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "hSgCe0RA67oM" + }, + "outputs": [], + "source": [ + "data = pd.read_csv('Admittance.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "colab_type": "code", + "id": "a19Zmvij7Xsq", + "outputId": "48457280-76a6-4120-b4f8-960735b35e4d" + }, + "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", + "
ScoreAdmitted
01363No
11792Yes
21954Yes
31653No
41593No
\n", + "
" + ], + "text/plain": [ + " Score Admitted\n", + "0 1363 No\n", + "1 1792 Yes\n", + "2 1954 Yes\n", + "3 1653 No\n", + "4 1593 No" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "data['Admitted'] = data['Admitted'].map({'Yes':1, 'No':0})" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "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", + "
ScoreAdmitted
013630
117921
219541
316530
415930
\n", + "
" + ], + "text/plain": [ + " Score Admitted\n", + "0 1363 0\n", + "1 1792 1\n", + "2 1954 1\n", + "3 1653 0\n", + "4 1593 0" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "QotmOvecHI36" + }, + "source": [ + "## Variables" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "H-g8QnRSGA3O" + }, + "outputs": [], + "source": [ + "X = data['Score'] # Independent variable\n", + "y = data['Admitted'] # Dependent variable" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "dI1ejw-7HiDB" + }, + "source": [ + "## PLOT\n", + "\n", + "Let's plot the data to see its distribution before building our logistic function" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 291 + }, + "colab_type": "code", + "id": "ut5XnF8wHT4q", + "outputId": "715529c5-69cc-45d5-e27a-76e20154d7b9" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create a scatter plot of x (Scores) and y (Admitted)\n", + "plt.scatter(X,y, color='C0')\n", + "plt.xlabel('Score', fontsize = 20)\n", + "plt.ylabel('Admitted', fontsize = 20)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Observe from above plot that, values above 1700 fall under the value of 1(admitted). Therea are a few cases of outliers in our data." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "i2Jjeo3aRhW1" + }, + "source": [ + "## The Logit Function\n", + "Here, we are going to call the Logit function from statsmodel and fit it on our data" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "ibAxdnqQRlZ6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimization terminated successfully.\n", + " Current function value: 0.137766\n", + " Iterations 10\n" + ] + } + ], + "source": [ + "x_const = sm.add_constant(X)\n", + "reg_log = sm.Logit(y,x_const)\n", + "result = reg_log.fit()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "RxTjA2XAA1b6" + }, + "source": [ + "## Logistic Summary" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "2UlPlAfKA5mc" + }, + "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", + "
Logit Regression Results
Dep. Variable: Admitted No. Observations: 168
Model: Logit Df Residuals: 166
Method: MLE Df Model: 1
Date: Mon, 20 Apr 2020 Pseudo R-squ.: 0.7992
Time: 10:45:34 Log-Likelihood: -23.145
converged: True LL-Null: -115.26
Covariance Type: nonrobust LLR p-value: 5.805e-42
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
coef std err z P>|z| [0.025 0.975]
const -69.9128 15.737 -4.443 0.000 -100.756 -39.070
SAT 0.0420 0.009 4.454 0.000 0.024 0.060


Possibly complete quasi-separation: A fraction 0.27 of observations can be
perfectly predicted. This might indicate that there is complete
quasi-separation. In this case some parameters will not be identified." + ], + "text/plain": [ + "\n", + "\"\"\"\n", + " Logit Regression Results \n", + "==============================================================================\n", + "Dep. Variable: Admitted No. Observations: 168\n", + "Model: Logit Df Residuals: 166\n", + "Method: MLE Df Model: 1\n", + "Date: Mon, 20 Apr 2020 Pseudo R-squ.: 0.7992\n", + "Time: 10:45:34 Log-Likelihood: -23.145\n", + "converged: True LL-Null: -115.26\n", + "Covariance Type: nonrobust LLR p-value: 5.805e-42\n", + "==============================================================================\n", + " coef std err z P>|z| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const -69.9128 15.737 -4.443 0.000 -100.756 -39.070\n", + "SAT 0.0420 0.009 4.454 0.000 0.024 0.060\n", + "==============================================================================\n", + "\n", + "Possibly complete quasi-separation: A fraction 0.27 of observations can be\n", + "perfectly predicted. This might indicate that there is complete\n", + "quasi-separation. In this case some parameters will not be identified.\n", + "\"\"\"" + ] + }, + "execution_count": 80, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Interpreting the Log Table\n", + "\n", + "From the table abve, you can see that our function was able to identify 'Admitted'as the dependent variable. The model used is a Logit regression, while the method is Maximum Likelihood Estimation (Maximum likelihood estimation is a method that determines values for the parameters of a model.). It has clearly converged after classifyin 168 observations.\n", + "\n", + "The Pseudo R-squared is 0.80 which is within the 'acceptable region'. Pseudo R2 is a measure of how well variables of the model explain some phenomenon. If we have a pseudo-R value more than 0.5 then can form our expectation for the model.\n", + "\n", + "The Admitted variable is highly significant and its coefficient is 1.\n", + "\n", + "The constant is also significant and equals: -69.9\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "imqAD27oP0Lc" + }, + "source": [ + "## Logistic formula\n", + "\n", + "Let's covert the logistic regression formula to a python function" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "hBt-pNzZPzju" + }, + "outputs": [], + "source": [ + "def log_form(x,b0,b1):\n", + " return np.array(np.exp(b0+x*b1) / (1 + np.exp(b0+x*b1)))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "XmToMDMpSY_5" + }, + "source": [ + "## Sorting" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 748 + }, + "colab_type": "code", + "id": "VFfBEWX_SdVD", + "outputId": "a67d5992-3259-470c-aeae-807c383473bc" + }, + "outputs": [], + "source": [ + "# The params valeus are comming from when we fitted our logit function on the data above\n", + "f_sorted = np.sort(log_form(X,result.params[0],result.params[1]))\n", + "x_sorted = np.sort(np.array(X))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "colab_type": "text", + "id": "CKuWoq7YN_a7" + }, + "source": [ + "## Plot a Logistic Curve\n" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": { + "colab": {}, + "colab_type": "code", + "id": "SUjjHHh_H7QO" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(X,y,color='C0')\n", + "plt.xlabel('Score', fontsize = 20)\n", + "plt.ylabel('Admitted', fontsize = 20)\n", + "# Plotting the curve\n", + "plt.plot(x_sorted,f_sorted,color='C8')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can observe that our function fitted well on our data and even ignored the outliered values." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Testing the Model" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.00, 1.00, 1.00, 0.38, 0.05, 0.98, 0.99, 1.00, 1.00, 0.03, 1.00,\n", + " 1.00, 0.50, 0.00, 0.77, 1.00, 0.21, 0.22, 0.23, 1.00, 1.00, 1.00,\n", + " 0.00, 0.00, 0.91, 1.00, 0.22, 1.00, 1.00, 0.98, 0.00, 0.61, 0.41,\n", + " 1.00, 1.00, 1.00, 0.50, 1.00, 0.39, 0.00, 0.04, 0.20, 1.00, 0.00,\n", + " 1.00, 0.00, 0.98, 0.00, 0.00, 0.01, 0.01, 1.00, 0.80, 0.01, 1.00,\n", + " 0.00, 0.56, 0.95, 0.22, 0.99, 0.01, 0.89, 1.00, 1.00, 0.99, 0.00,\n", + " 0.00, 0.00, 1.00, 0.00, 0.89, 0.22, 0.00, 1.00, 1.00, 1.00, 0.00,\n", + " 0.49, 1.00, 1.00, 0.01, 1.00, 1.00, 0.65, 1.00, 1.00, 0.00, 1.00,\n", + " 0.99, 0.72, 0.60, 0.00, 0.95, 0.91, 0.00, 1.00, 1.00, 0.01, 0.98,\n", + " 0.88, 0.99, 0.00, 0.99, 0.03, 0.00, 0.99, 0.99, 1.00, 0.00, 0.00,\n", + " 0.04, 0.52, 0.00, 1.00, 0.16, 0.00, 0.92, 0.00, 0.47, 1.00, 1.00,\n", + " 0.02, 0.00, 0.00, 1.00, 0.01, 0.96, 0.75, 0.72, 0.94, 0.60, 0.00,\n", + " 1.00, 0.00, 0.00, 0.00, 1.00, 0.08, 0.00, 0.01, 1.00, 0.98, 0.70,\n", + " 0.99, 1.00, 0.02, 0.00, 0.00, 0.00, 0.83, 1.00, 1.00, 1.00, 1.00,\n", + " 1.00, 0.00, 1.00, 1.00, 0.01, 1.00, 0.05, 1.00, 1.00, 0.92, 0.97,\n", + " 0.01, 0.00, 0.00])" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.predict()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The above predicted values shows that probability of a value being a 1 or 0. The first observation (0.0) shows an a hundread percent accuracy of a number being a 0 which implies no admission, while the secsond observation shows a hundread percent accuracy of a student being admitted with a value of 1. Other values which are neither 1 or 0 are outliers which are not fully sure of which of the class they belong to. This was visually seen in our plot above." + ] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "logistic_challenge.ipynb", + "provenance": [], + "toc_visible": true + }, + "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": 4 +} From 28ddf0523814646e6634b4cb48a9b93258a4f4d3 Mon Sep 17 00:00:00 2001 From: jatojoseph Date: Mon, 20 Apr 2020 11:29:45 +0100 Subject: [PATCH 2/4] Update README.md --- README.md | 40 ---------------------------------------- 1 file changed, 40 deletions(-) diff --git a/README.md b/README.md index d3696d5..8b13789 100644 --- a/README.md +++ b/README.md @@ -1,41 +1 @@ -# ML-Logistic-regression-algorithm-challenge - -![DSN logo](DSN_logo.png)|DSN Algorithm Challenge| -|---|---| - -A lot of data scientists or machine learning enthusiasts do use various machine learning algorithms as a black box without knowing how they work or the mathematics behind it. The purpose of this challenge is to encourage the mathematical understanding of machine learning algorithms, their break and yield point. - -In summary, participants are encouraged to understand the fundamental concepts behind machine learning algorithms/models. - - -The rules and guidelines for this challenge are as follows: - -1. Ensure to register at https://bit.ly/dsnmlhack - -2. The algorithm challenge is open to all. - -3. Participants are expected to design and develop the Logistic Regression algorithm from scratch using Python or R programming. - -4. For python developers (numpy is advisable). - -5. To push your solution to us, make a [pull request](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/about-pull-requests) to DSN's GitHub page at https://www.github.com/datasciencenigeria/ML-Logistic-regression-algorithm-challenge. Ensure to add your readme file to understand your code. - -6. The top 3 optimized code will be compensated as follows: - -- **1st position**: 20GB data plan. -- **2nd position**: 15GB data plan. -- **3rd position**: 10GB data plan. - -7. Add your scripts and readme.MD file as a folder saved as your full name (surname_first_middle name) by making a pull request to the repository. - ---- -For issues on this challenge kindly reach out to the AI+campus/city managers - -**Twitter**: [@DataScienceNIG](https://twitter.com/DataScienceNIG), [@elishatofunmi](https://twitter.com/Elishatofunmi), [@o_funminiyi](https://twitter.com/o_funminiyi), [@gbganalyst](https://twitter.com/gbganalyst) - -or - -**Call**: +2349062000119,+2349080564419. - -Good luck! From ff4f0ce90b056fb02d237c423d9ae8a1db576a38 Mon Sep 17 00:00:00 2001 From: jatojoseph Date: Mon, 20 Apr 2020 11:30:14 +0100 Subject: [PATCH 3/4] Delete README.md --- README.md | 1 - 1 file changed, 1 deletion(-) delete mode 100644 README.md diff --git a/README.md b/README.md deleted file mode 100644 index 8b13789..0000000 --- a/README.md +++ /dev/null @@ -1 +0,0 @@ - From b2f34dc835401e67c4e8828343824e74f4549e2d Mon Sep 17 00:00:00 2001 From: jatojoseph Date: Mon, 20 Apr 2020 11:30:59 +0100 Subject: [PATCH 4/4] Added a readme file --- README.md | 44 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 44 insertions(+) create mode 100644 README.md diff --git a/README.md b/README.md new file mode 100644 index 0000000..511b69a --- /dev/null +++ b/README.md @@ -0,0 +1,44 @@ +# ML-Logistic-regression-algorithm-challenge +ML-Logistic-regression-algorithm-challenge +## Logistic Regression +Logistic regression is a statistical model that in its basic form uses a logistic function to model a binary dependent variable.The possible outcomes of a logistic regression are not numerical but +rather categorical ( 1 or 0, Yes or No ) etc. + +Even though a Logistic regression is seen as a generalized linear model, It is a linear model with a link function that maps the output of linear multiple regression to a posterior probability of each class (0,1) using the **logistic +sigmoid function.** + +## The Logistic Regression Formla + + +## $p(X)/1 −p (X) = e ( β 0 +β 1 X 1 +...+β k X k )$ + +Where, + +$p(X)$ = Probability of the dsitribution + +$e$ = Base of the Natural Log + +$β0$ = Biase or Intercept + +$β1$ = Coefficient + +$X1$ = Independenet variable + +## **ODDS** = $p (X)/1 −p (X)$ + +The logistic regression model is not very useful in itself. The right-hand side of the model is an exponent which is very computationally inefficient and generally hard to grasp. + +When we talk about a *logistic regression* what we usually mean is **logit regression** – which is a variation of the model where we have taken the log of both sides. See formula below: + +## $log(p(X)/1 −p(X)) = log(e(β 0 + β 1 x + ⋯ β k x k))$ + +On the right hand side, log cancels 'e(exponential)' function leavig us with our new formula: + +## $log(p(X)/1 −p(X)) = β 0 + β 1 x + ⋯ β k x k$ + +With odds: + +## $log (odds) = β 0 + β 1 x + ⋯ β k x k$ + +We'll implemt all these in the code section of the project. +