From 5ed3d9342ebf1f6a953ba78f502b61cfbf985725 Mon Sep 17 00:00:00 2001 From: jinw00jun <79273189+jinw00jun@users.noreply.github.com> Date: Thu, 18 Feb 2021 22:35:18 -0500 Subject: [PATCH 1/6] Create aNewReadme.md A new directory and a new markdown file was created. --- Test/aNewReadme.md | 1 + 1 file changed, 1 insertion(+) create mode 100644 Test/aNewReadme.md diff --git a/Test/aNewReadme.md b/Test/aNewReadme.md new file mode 100644 index 00000000..95993f45 --- /dev/null +++ b/Test/aNewReadme.md @@ -0,0 +1 @@ +New markdown file 'aNewReadme.md' was made in the forked course github repo. From bec72b738609ef34c0fea0dd1c965eb2788f731a Mon Sep 17 00:00:00 2001 From: jinw00jun <79273189+jinw00jun@users.noreply.github.com> Date: Thu, 18 Feb 2021 22:35:43 -0500 Subject: [PATCH 2/6] Update aNewReadme.md --- Test/aNewReadme.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Test/aNewReadme.md b/Test/aNewReadme.md index 95993f45..8720f415 100644 --- a/Test/aNewReadme.md +++ b/Test/aNewReadme.md @@ -1 +1,2 @@ -New markdown file 'aNewReadme.md' was made in the forked course github repo. +# New markdown file 'aNewReadme.md' was made in the forked course github repo. +assignment 1 From a5bfac96723b4ffe7a4090546b7a97ac738c0055 Mon Sep 17 00:00:00 2001 From: jinw00jun <79273189+jinw00jun@users.noreply.github.com> Date: Thu, 18 Feb 2021 22:36:35 -0500 Subject: [PATCH 3/6] Update aNewReadme.md --- Test/aNewReadme.md | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Test/aNewReadme.md b/Test/aNewReadme.md index 8720f415..05011984 100644 --- a/Test/aNewReadme.md +++ b/Test/aNewReadme.md @@ -1,2 +1,3 @@ -# New markdown file 'aNewReadme.md' was made in the forked course github repo. -assignment 1 +# Assignment 1 +New markdown file 'aNewReadme.md' was made in newly added `test` directory of the forked course github repo. + From be3e07724a75690395e56668b050bbcb4e2083db Mon Sep 17 00:00:00 2001 From: jinw00jun <79273189+jinw00jun@users.noreply.github.com> Date: Thu, 18 Feb 2021 22:36:48 -0500 Subject: [PATCH 4/6] Update aNewReadme.md --- Test/aNewReadme.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Test/aNewReadme.md b/Test/aNewReadme.md index 05011984..b47d734d 100644 --- a/Test/aNewReadme.md +++ b/Test/aNewReadme.md @@ -1,3 +1,3 @@ # Assignment 1 -New markdown file 'aNewReadme.md' was made in newly added `test` directory of the forked course github repo. +New markdown file `aNewReadme.md` was made in newly added `test` directory of the forked course github repo. From f11817b1d1d7d6df61e7c882d8bcd3b463a29ec8 Mon Sep 17 00:00:00 2001 From: jinw00jun <79273189+jinw00jun@users.noreply.github.com> Date: Mon, 12 Apr 2021 15:27:27 -0400 Subject: [PATCH 5/6] HW7. Created using Colaboratory --- HW7_colab.ipynb | 698 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 698 insertions(+) create mode 100644 HW7_colab.ipynb diff --git a/HW7_colab.ipynb b/HW7_colab.ipynb new file mode 100644 index 00000000..4dd366fb --- /dev/null +++ b/HW7_colab.ipynb @@ -0,0 +1,698 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Copy of Untitled0.ipynb", + "provenance": [], + "authorship_tag": "ABX9TyNZ4mYUsREhwFWjwd8bPgWn", + "include_colab_link": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mzjhcuWShQ5o" + }, + "source": [ + "Libraries used" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "LYe1huaSQI0q", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "7dc6d907-2dcd-44d4-b225-9307dfbba91b" + }, + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import statsmodels.formula.api as smf" + ], + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/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": "Wlydw3AlhVY3" + }, + "source": [ + "Loading shhs.txt data file as a dataframe using pandas " + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "resources": { + "http://localhost:8080/nbextensions/google.colab/files.js": { + "data": "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", + "ok": true, + "headers": [ + [ + "content-type", + "application/javascript" + ] + ], + "status": 200, + "status_text": "" + } + }, + "base_uri": "https://localhost:8080/", + "height": 227 + }, + "id": "R2PBlW5ATiGX", + "outputId": "e710df31-23f1-4cd1-f1ad-110ba0f1ae1e" + }, + "source": [ + "from google.colab import files\n", + "uploaded = files.upload()" + ], + "execution_count": 2, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/html": [ + "\n", + " \n", + " \n", + " Upload widget is only available when the cell has been executed in the\n", + " current browser session. Please rerun this cell to enable.\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "Saving shhs.txt to shhs (2).txt\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "KMH5FqlATiIw" + }, + "source": [ + "import io\n", + "shhs = pd.read_csv(io.BytesIO(uploaded['shhs.txt']))" + ], + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 372 + }, + "id": "LkYva6sZTiLP", + "outputId": "83adc35f-7186-4f81-df82-686407840dc9" + }, + "source": [ + "shhs.head()" + ], + "execution_count": 4, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pptidclinicWaistCOPD15ASTHMA15slp_lattime_bedtimest1ptimest2ptimes34ptimeremprdi4pStLOutPStOnsetPSlpPrdPStaging1Staging2Staging3Staging4Staging5RestAn1RestAn2RestAn3RestAn4HTNCVDCHDsexagesmokstatusbmi
00007418600.440.56.25832260.85219619.3075913.5818911.438083282822530000101000100155Former21.78
100094110700.225.00.82417665.6593416.75824216.75824217.8021980010920.........100178Never32.95
20028418200.431.54.88145140.30683542.81729511.9944214.85355616716721510100001000000077Never24.11
3003941850014358.52.99003329.40199352.32558115.2823930.797342548218060100001000100148Never20.19
400454176006.5477.05.67567668.64865113.37837812.2972972.75675772022200100001000100066Former23.31
\n", + "
" + ], + "text/plain": [ + " pptid clinic Waist COPD15 ASTHMA15 ... CHD sex age smokstatus bmi\n", + "0 0007 41 86 0 0 ... 0 1 55 Former 21.78\n", + "1 0009 41 107 0 0 ... 0 1 78 Never 32.95\n", + "2 0028 41 82 0 0 ... 0 0 77 Never 24.11\n", + "3 0039 41 85 0 0 ... 0 1 48 Never 20.19\n", + "4 0045 41 76 0 0 ... 0 0 66 Former 23.31\n", + "\n", + "[5 rows x 31 columns]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 4 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7FSPXxOPhffP" + }, + "source": [ + "Because bmi values are read as characters, convert it to numeric and drop NA values.\n", + " " + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "iT9uR3AHcMRQ", + "outputId": "5cf76c98-213a-4ec7-890e-85fb836bd076" + }, + "source": [ + "df = shhs[['bmi', 'rdi4p']]\n", + "df['bmi'] = pd.to_numeric(df['bmi'],errors='coerce')\n", + "df = df.dropna()\n", + "df['log_rdi4p'] = np.log(df.rdi4p + 1)" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py:2: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " \n" + ], + "name": "stderr" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_H96Yud2htWm" + }, + "source": [ + "Fitting linear model." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 542 + }, + "id": "hQ1Zr7xrTiZI", + "outputId": "4f84793a-4e83-440b-ebdc-53b97a0430a6" + }, + "source": [ + "fit = smf.ols('log_rdi4p ~ bmi', data = df).fit()\n", + "fit.summary()" + ], + "execution_count": 6, + "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", + "
OLS Regression Results
Dep. Variable: log_rdi4p R-squared: 0.133
Model: OLS Adj. R-squared: 0.133
Method: Least Squares F-statistic: 973.8
Date: Mon, 12 Apr 2021 Prob (F-statistic): 5.47e-199
Time: 19:24:45 Log-Likelihood: -8893.0
No. Observations: 6333 AIC: 1.779e+04
Df Residuals: 6331 BIC: 1.780e+04
Df Model: 1
Covariance Type: nonrobust
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
coef std err t P>|t| [0.025 0.975]
Intercept -0.3430 0.067 -5.111 0.000 -0.475 -0.211
bmi 0.0722 0.002 31.207 0.000 0.068 0.077
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Omnibus: 202.903 Durbin-Watson: 1.967
Prob(Omnibus): 0.000 Jarque-Bera (JB): 144.575
Skew: 0.266 Prob(JB): 4.04e-32
Kurtosis: 2.485 Cond. No. 157.


Warnings:
[1] Standard Errors assume that the covariance matrix of the errors is correctly specified." + ], + "text/plain": [ + "\n", + "\"\"\"\n", + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: log_rdi4p R-squared: 0.133\n", + "Model: OLS Adj. R-squared: 0.133\n", + "Method: Least Squares F-statistic: 973.8\n", + "Date: Mon, 12 Apr 2021 Prob (F-statistic): 5.47e-199\n", + "Time: 19:24:45 Log-Likelihood: -8893.0\n", + "No. Observations: 6333 AIC: 1.779e+04\n", + "Df Residuals: 6331 BIC: 1.780e+04\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "Intercept -0.3430 0.067 -5.111 0.000 -0.475 -0.211\n", + "bmi 0.0722 0.002 31.207 0.000 0.068 0.077\n", + "==============================================================================\n", + "Omnibus: 202.903 Durbin-Watson: 1.967\n", + "Prob(Omnibus): 0.000 Jarque-Bera (JB): 144.575\n", + "Skew: 0.266 Prob(JB): 4.04e-32\n", + "Kurtosis: 2.485 Cond. No. 157.\n", + "==============================================================================\n", + "\n", + "Warnings:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\"\"\"" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 6 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4_6BGfViieZl" + }, + "source": [ + "Scatter plot + fitted line. " + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "mwrKbjqAfDjn" + }, + "source": [ + "yhat = fit.predict(df.bmi)" + ], + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 451 + }, + "id": "E5aih7x4fDmX", + "outputId": "0239b774-374e-44aa-d7d2-17f7f667ffdb" + }, + "source": [ + "sns.scatterplot(data = df, x= 'bmi', y = 'log_rdi4p' )\n", + "plt.plot(df.bmi, yhat, color='r')" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 8 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qE6KMkzqh5TD" + }, + "source": [ + "Estimation of rdi4p when bmi = 30. \n", + "\n", + "**The predicted rdi4p is 5.19241304**" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Xy3b721ifDhL" + }, + "source": [ + "intercept = fit.params[0]\n", + "b1 = fit.params[1]" + ], + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "JcdznwrkfDoi" + }, + "source": [ + "bmi_val = 30\n", + "predicted_log_rdi4p = intercept + b1 * bmi_val\n", + "predicted_rdi4p = np.exp(predicted_log_rdi4p)-1" + ], + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HlbqqZ5LhKw_", + "outputId": "3a0c86f9-fb15-4cc0-f29c-2a6ae69e46cb" + }, + "source": [ + "print(predicted_rdi4p)" + ], + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "text": [ + "5.192413044073733\n" + ], + "name": "stdout" + } + ] + } + ] +} \ No newline at end of file From 13276b3f10a3bbab3f80b65143747ce0ad3f1209 Mon Sep 17 00:00:00 2001 From: jinw00jun <79273189+jinw00jun@users.noreply.github.com> Date: Mon, 12 Apr 2021 15:33:51 -0400 Subject: [PATCH 6/6] Created using Colaboratory --- HW7_colab.ipynb | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/HW7_colab.ipynb b/HW7_colab.ipynb index 4dd366fb..43743e36 100644 --- a/HW7_colab.ipynb +++ b/HW7_colab.ipynb @@ -5,7 +5,7 @@ "colab": { "name": "Copy of Untitled0.ipynb", "provenance": [], - "authorship_tag": "ABX9TyNZ4mYUsREhwFWjwd8bPgWn", + "authorship_tag": "ABX9TyOgN9LM174c9Rddp32i5QsD", "include_colab_link": true }, "kernelspec": { @@ -658,6 +658,31 @@ "execution_count": 9, "outputs": [] }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RoG6WkCAkePy", + "outputId": "36d03790-2807-41bd-aa14-f1ecd94377a8" + }, + "source": [ + "print(intercept)\n", + "print(b1)" + ], + "execution_count": 12, + "outputs": [ + { + "output_type": "stream", + "text": [ + "-0.3430244378036704\n", + "0.07221164259835346\n" + ], + "name": "stdout" + } + ] + }, { "cell_type": "code", "metadata": {