diff --git a/module4/src_Python3_challenger.ipynb b/module4/src_Python3_challenger.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..f04b6ee938ae0e3e130d550fe73c02318fe9f2bb --- /dev/null +++ b/module4/src_Python3_challenger.ipynb @@ -0,0 +1,741 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.7.4 (default, Aug 9 2019, 18:34:13) [MSC v.1915 64 bit (AMD64)]\n", + "uname_result(system='Windows', node='LAPTOP-TL7KUKIV', release='10', version='10.0.18362', machine='AMD64', processor='Intel64 Family 6 Model 158 Stepping 10, GenuineIntel')\n", + "IPython 7.8.0\n", + "IPython.core.release 7.8.0\n", + "PIL 6.2.0\n", + "PIL.Image 6.2.0\n", + "PIL._version 6.2.0\n", + "_csv 1.0\n", + "_ctypes 1.1.0\n", + "decimal 1.70\n", + "argparse 1.1\n", + "backcall 0.1.0\n", + "bottleneck 1.2.1\n", + "bottleneck.version 1.2.1\n", + "cffi 1.12.3\n", + "colorama 0.4.1\n", + "csv 1.0\n", + "ctypes 1.1.0\n", + "cycler 0.10.0\n", + "dateutil 2.8.0\n", + "decimal 1.70\n", + "decorator 4.4.0\n", + "distutils 3.7.4\n", + "ipykernel 5.1.2\n", + "ipykernel._version 5.1.2\n", + "ipython_genutils 0.2.0\n", + "ipython_genutils._version 0.2.0\n", + "ipywidgets 7.5.1\n", + "ipywidgets._version 7.5.1\n", + "jedi 0.15.1\n", + "joblib 0.13.2\n", + "joblib.externals.cloudpickle 0.8.0\n", + "joblib.externals.loky 2.4.2\n", + "json 2.0.9\n", + "jupyter_client 5.3.3\n", + "jupyter_client._version 5.3.3\n", + "jupyter_core 4.5.0\n", + "jupyter_core.version 4.5.0\n", + "kiwisolver 1.1.0\n", + "logging 0.5.1.2\n", + "matplotlib 3.1.1\n", + "matplotlib.backends.backend_agg 3.1.1\n", + "numpy 1.19.0\n", + "numpy.core 1.19.0\n", + "numpy.core._multiarray_umath 3.1\n", + "numpy.lib 1.19.0\n", + "numpy.linalg._umath_linalg b'0.1.5'\n", + "pandas 0.25.1\n", + "_libjson 1.33\n", + "parso 0.5.1\n", + "patsy 0.5.1\n", + "patsy.version 0.5.1\n", + "pickleshare 0.7.5\n", + "platform 1.0.8\n", + "prompt_toolkit 2.0.10\n", + "psutil 5.6.3\n", + "pygments 2.4.2\n", + "pyparsing 2.4.2\n", + "pytz 2019.3\n", + "re 2.2.1\n", + "scipy 1.5.0\n", + "scipy._lib._uarray 0.5.1+49.g4c3f1d7.scipy\n", + "scipy._lib.decorator 4.0.5\n", + "scipy.integrate._dop b'$Revision: $'\n", + "scipy.integrate._ode $Id$\n", + "scipy.integrate._odepack 1.9 \n", + "scipy.integrate._quadpack 1.13 \n", + "scipy.integrate.lsoda b'$Revision: $'\n", + "scipy.integrate.vode b'$Revision: $'\n", + "scipy.interpolate._fitpack 1.7 \n", + "scipy.interpolate.dfitpack b'$Revision: $'\n", + "scipy.linalg._fblas b'$Revision: $'\n", + "scipy.linalg._flapack b'$Revision: $'\n", + "scipy.linalg._flinalg b'$Revision: $'\n", + "scipy.ndimage 2.0\n", + "scipy.optimize.__nnls b'$Revision: $'\n", + "scipy.optimize._cobyla b'$Revision: $'\n", + "scipy.optimize._lbfgsb b'$Revision: $'\n", + "scipy.optimize._minpack 1.10 \n", + "scipy.optimize._slsqp b'$Revision: $'\n", + "scipy.optimize.minpack2 b'$Revision: $'\n", + "scipy.signal.spline 0.2\n", + "scipy.sparse.linalg.eigen.arpack._arpack b'$Revision: $'\n", + "scipy.sparse.linalg.isolve._iterative b'$Revision: $'\n", + "scipy.special.specfun b'$Revision: $'\n", + "scipy.stats.mvn b'$Revision: $'\n", + "scipy.stats.statlib b'$Revision: $'\n", + "seaborn 0.9.0\n", + "seaborn.external.husl 2.1.0\n", + "seaborn.external.six 1.10.0\n", + "six 1.12.0\n", + "statsmodels 0.10.1\n", + "statsmodels.__init__ 0.10.1\n", + "statsmodels.api 0.10.1\n", + "statsmodels.tools.web 0.10.1\n", + "traitlets 4.3.3\n", + "traitlets._version 4.3.3\n", + "urllib.request 3.7\n", + "zlib 1.0\n", + "zmq 18.1.0\n", + "zmq.sugar 18.1.0\n", + "zmq.sugar.version 18.1.0\n" + ] + } + ], + "source": [ + "def print_imported_modules():\n", + " import sys\n", + " for name, val in sorted(sys.modules.items()):\n", + " if(hasattr(val, '__version__')): \n", + " print(val.__name__, val.__version__)\n", + "# else:\n", + "# print(val.__name__, \"(unknown version)\")\n", + "def print_sys_info():\n", + " import sys\n", + " import platform\n", + " print(sys.version)\n", + " print(platform.uname())\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import statsmodels.api as sm\n", + "import seaborn as sns\n", + "\n", + "print_sys_info()\n", + "print_imported_modules()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Loading and inspecting data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's start by reading data." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "scrolled": false + }, + "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", + " \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", + " \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", + " \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", + "
DateCountTemperaturePressureMalfunction
04/12/81666500
111/12/81670501
23/22/82669500
311/11/82668500
44/04/83667500
56/18/82672500
68/30/836731000
711/28/836701000
82/03/846572001
94/06/846632001
108/30/846702001
1110/05/846782000
1211/08/846672000
131/24/856532002
144/12/856672000
154/29/856752000
166/17/856702000
177/2903/856812000
188/27/856762000
1910/03/856792000
2010/30/856752002
2111/26/856762000
221/12/866582001
\n", + "
" + ], + "text/plain": [ + " Date Count Temperature Pressure Malfunction\n", + "0 4/12/81 6 66 50 0\n", + "1 11/12/81 6 70 50 1\n", + "2 3/22/82 6 69 50 0\n", + "3 11/11/82 6 68 50 0\n", + "4 4/04/83 6 67 50 0\n", + "5 6/18/82 6 72 50 0\n", + "6 8/30/83 6 73 100 0\n", + "7 11/28/83 6 70 100 0\n", + "8 2/03/84 6 57 200 1\n", + "9 4/06/84 6 63 200 1\n", + "10 8/30/84 6 70 200 1\n", + "11 10/05/84 6 78 200 0\n", + "12 11/08/84 6 67 200 0\n", + "13 1/24/85 6 53 200 2\n", + "14 4/12/85 6 67 200 0\n", + "15 4/29/85 6 75 200 0\n", + "16 6/17/85 6 70 200 0\n", + "17 7/2903/85 6 81 200 0\n", + "18 8/27/85 6 76 200 0\n", + "19 10/03/85 6 79 200 0\n", + "20 10/30/85 6 75 200 2\n", + "21 11/26/85 6 76 200 0\n", + "22 1/12/86 6 58 200 1" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = pd.read_csv(\"C:/Users/hugoc/Downloads/shuttle.csv\", delimiter=',')\n", + "data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We know from our previous experience on this data set that filtering data is a really bad idea. We will therefore process it as such." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + " %matplotlib inline\n", + "pd.set_option('mode.chained_assignment',None) # this removes a useless warning from pandas\n", + "import matplotlib.pyplot as plt\n", + "\n", + "data[\"Frequency\"]=data.Malfunction/data.Count\n", + "data.plot(x=\"Temperature\",y=\"Frequency\",kind=\"scatter\",ylim=[0,1])\n", + "plt.grid(True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Logistic regression" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's assume O-rings independently fail with the same probability which solely depends on temperature. A logistic regression should allow us to estimate the influence of temperature." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\hugoc\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:7: DeprecationWarning: Calling Family(..) with a link class as argument is deprecated.\n", + "Use an instance of a link class instead.\n", + " import sys\n" + ] + }, + { + "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", + "
Generalized Linear Model Regression Results
Dep. Variable: Frequency No. Observations: 23
Model: GLM Df Residuals: 21
Model Family: Binomial Df Model: 1
Link Function: logit Scale: 1.0000
Method: IRLS Log-Likelihood: -3.9210
Date: Wed, 12 Aug 2020 Deviance: 3.0144
Time: 16:46:29 Pearson chi2: 5.00
No. Iterations: 6
Covariance Type: nonrobust
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
coef std err z P>|z| [0.025 0.975]
Intercept 5.0850 7.477 0.680 0.496 -9.570 19.740
Temperature -0.1156 0.115 -1.004 0.316 -0.341 0.110
" + ], + "text/plain": [ + "\n", + "\"\"\"\n", + " Generalized Linear Model Regression Results \n", + "==============================================================================\n", + "Dep. Variable: Frequency No. Observations: 23\n", + "Model: GLM Df Residuals: 21\n", + "Model Family: Binomial Df Model: 1\n", + "Link Function: logit Scale: 1.0000\n", + "Method: IRLS Log-Likelihood: -3.9210\n", + "Date: Wed, 12 Aug 2020 Deviance: 3.0144\n", + "Time: 16:46:29 Pearson chi2: 5.00\n", + "No. Iterations: 6 \n", + "Covariance Type: nonrobust \n", + "===============================================================================\n", + " coef std err z P>|z| [0.025 0.975]\n", + "-------------------------------------------------------------------------------\n", + "Intercept 5.0850 7.477 0.680 0.496 -9.570 19.740\n", + "Temperature -0.1156 0.115 -1.004 0.316 -0.341 0.110\n", + "===============================================================================\n", + "\"\"\"" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import statsmodels.api as sm\n", + "\n", + "data[\"Success\"]=data.Count-data.Malfunction\n", + "data[\"Intercept\"]=1\n", + "\n", + "logmodel=sm.GLM(data['Frequency'], data[['Intercept','Temperature']], \n", + " family=sm.families.Binomial(sm.families.links.logit)).fit()\n", + "\n", + "logmodel.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\hugoc\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:2: DeprecationWarning: Calling Family(..) with a link class as argument is deprecated.\n", + "Use an instance of a link class instead.\n", + " \n" + ] + }, + { + "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", + "
Generalized Linear Model Regression Results
Dep. Variable: Frequency No. Observations: 23
Model: GLM Df Residuals: 21
Model Family: Binomial Df Model: 1
Link Function: logit Scale: 1.0000
Method: IRLS Log-Likelihood: -23.526
Date: Wed, 12 Aug 2020 Deviance: 18.086
Time: 16:46:29 Pearson chi2: 30.0
No. Iterations: 6
Covariance Type: nonrobust
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
coef std err z P>|z| [0.025 0.975]
Intercept 5.0850 3.052 1.666 0.096 -0.898 11.068
Temperature -0.1156 0.047 -2.458 0.014 -0.208 -0.023
" + ], + "text/plain": [ + "\n", + "\"\"\"\n", + " Generalized Linear Model Regression Results \n", + "==============================================================================\n", + "Dep. Variable: Frequency No. Observations: 23\n", + "Model: GLM Df Residuals: 21\n", + "Model Family: Binomial Df Model: 1\n", + "Link Function: logit Scale: 1.0000\n", + "Method: IRLS Log-Likelihood: -23.526\n", + "Date: Wed, 12 Aug 2020 Deviance: 18.086\n", + "Time: 16:46:29 Pearson chi2: 30.0\n", + "No. Iterations: 6 \n", + "Covariance Type: nonrobust \n", + "===============================================================================\n", + " coef std err z P>|z| [0.025 0.975]\n", + "-------------------------------------------------------------------------------\n", + "Intercept 5.0850 3.052 1.666 0.096 -0.898 11.068\n", + "Temperature -0.1156 0.047 -2.458 0.014 -0.208 -0.023\n", + "===============================================================================\n", + "\"\"\"" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + " logmodel=sm.GLM(data['Frequency'], data[['Intercept','Temperature']], \n", + " family=sm.families.Binomial(sm.families.links.logit),\n", + " var_weights=data['Count']).fit()\n", + "\n", + "logmodel.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + " %matplotlib inline\n", + "data_pred = pd.DataFrame({'Temperature': np.linspace(start=30, stop=90, num=121), 'Intercept': 1})\n", + "data_pred['Frequency'] = logmodel.predict(data_pred)\n", + "data_pred.plot(x=\"Temperature\",y=\"Frequency\",kind=\"line\",ylim=[0,1])\n", + "plt.scatter(x=data[\"Temperature\"],y=data[\"Frequency\"])\n", + "plt.grid(True)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set(color_codes=True)\n", + "plt.xlim(30,90)\n", + "plt.ylim(0,1)\n", + "sns.regplot(x='Temperature', y='Frequency', data=data, logistic=True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}