diff --git a/.gitignore b/.gitignore index c77715b..a387d0f 100644 --- a/.gitignore +++ b/.gitignore @@ -1,12 +1,13 @@ +# Specific to this repo +develop_log.md +*hw* + # Compiled source *.o *.out *.so *.exe -develop_log.md -*hw* - # Jupyter Notebook .ipynb_checkpoints diff --git a/regression/[play] polynomial regression.ipynb b/regression/[play] polynomial regression.ipynb new file mode 100644 index 0000000..24d0373 --- /dev/null +++ b/regression/[play] polynomial regression.ipynb @@ -0,0 +1,480 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "792c583e", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import PolynomialFeatures\n", + "from sklearn.linear_model import LinearRegression" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4f50f5fd", + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
x1x2y
016.24345413.413857570.412369
16.11756436.735231111.681987
25.28171812.10474962.392124
310.72968617.807356303.538953
48.65407632.847355151.109269
............
950.77340148.823150-0.430738
963.43853718.06957844.308720
970.43596912.60846619.383456
986.20000824.32855078.371729
996.98032031.333263132.108914
\n", + "

100 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " x1 x2 y\n", + "0 16.243454 13.413857 570.412369\n", + "1 6.117564 36.735231 111.681987\n", + "2 5.281718 12.104749 62.392124\n", + "3 10.729686 17.807356 303.538953\n", + "4 8.654076 32.847355 151.109269\n", + ".. ... ... ...\n", + "95 0.773401 48.823150 -0.430738\n", + "96 3.438537 18.069578 44.308720\n", + "97 0.435969 12.608466 19.383456\n", + "98 6.200008 24.328550 78.371729\n", + "99 6.980320 31.333263 132.108914\n", + "\n", + "[100 rows x 3 columns]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.random.seed(1)\n", + "x1 = np.absolute(np.random.randn(100, 1)*10)\n", + "x2 = np.absolute(np.random.randn(100, 1)*30)\n", + "y = 2*x1**2 + 3*x1 + 2 + np.random.randn(100, 1)*20\n", + "\n", + "df = pd.DataFrame({\"x1\": x1.reshape(100,), \"x2\": x2.reshape(100,), \"y\": y.reshape(100,)}, index=range(0,100))\n", + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "c2199717", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(10, 4))\n", + "\n", + "ax[0].scatter(x1, y)\n", + "ax[1].scatter(x2, y)\n", + "\n", + "for i in range(2):\n", + " ax[i].set_title(f'y v.s. x{i}')\n", + " ax[i].set_xlabel(f'x{i}')\n", + " ax[i].set_ylabel('y')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "82f2b66f", + "metadata": {}, + "outputs": [], + "source": [ + "X, y = df[[\"x1\", \"x2\"]], df[\"y\"]\n", + "\n", + "poly = PolynomialFeatures(degree=2, include_bias=False)\n", + "#poly = PolynomialFeatures(degree=2, include_bias=False, interaction_only = True)\n", + "poly_features = poly.fit_transform(X)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "cb4d561d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(100, 5)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "poly_features.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8799040e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Column names in poly_features: ['x1' 'x2' 'x1^2' 'x1 x2' 'x2^2']\n" + ] + } + ], + "source": [ + "feature_names = poly.get_feature_names_out()\n", + "print(\"Column names in poly_features:\", feature_names)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ebf1cd54", + "metadata": {}, + "outputs": [], + "source": [ + "X_train, X_test, y_train, y_test = train_test_split(poly_features, y, test_size=0.3, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "e547e5eb", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
LinearRegression()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "LinearRegression()" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "poly_reg_model = LinearRegression()\n", + "poly_reg_model.fit(X_train, y_train)" + ] + }, + { + "cell_type": "markdown", + "id": "1bc011b1", + "metadata": {}, + "source": [ + "## Check MSE" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "78e12296", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "20.93770783907864" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "poly_reg_y_predicted = poly_reg_model.predict(X_test)\n", + "from sklearn.metrics import mean_squared_error\n", + "poly_reg_rmse = np.sqrt(mean_squared_error(y_test, poly_reg_y_predicted))\n", + "poly_reg_rmse" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "df81c379", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "62.30248745387846" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_trainL, X_testL, y_trainL, y_testL = train_test_split(X, y, test_size=0.3, random_state=42)\n", + "lin_reg_model = LinearRegression()\n", + "lin_reg_model.fit(X_trainL, y_trainL)\n", + "lin_reg_y_predicted = lin_reg_model.predict(X_testL)\n", + "lin_reg_rmse = np.sqrt(mean_squared_error(y_testL, lin_reg_y_predicted))\n", + "lin_reg_rmse" + ] + }, + { + "cell_type": "markdown", + "id": "b9b8576c", + "metadata": {}, + "source": [ + "## Check fitted equation" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "478a716d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitted Polynomial Function: \n", + " \t f(x1, x2) ~ 14.12 + 3.62 * x1 + -1.09 * x2 + 1.90 * x1^2 + 0.02 * x1 x2 + 0.01 * x2^2\n" + ] + } + ], + "source": [ + "feature_names = poly.get_feature_names_out()\n", + "\n", + "coefficients = poly_reg_model.coef_\n", + "intercept = poly_reg_model.intercept_\n", + "\n", + "poly_string = f\"{intercept:.2f}\"\n", + "\n", + "for i, coef in enumerate(coefficients):\n", + " poly_string += f\" + {coef:.2f} * {feature_names[i]}\"\n", + "\n", + "print(\"Fitted Polynomial Function: \\n \\t f(x1, x2) ~\", poly_string)" + ] + }, + { + "cell_type": "markdown", + "id": "0e5496c2", + "metadata": {}, + "source": [ + "### Check results" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a902b078", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(30, 5)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_test.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "acec4767", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 41.6350313 , 39.42128746, 452.06683015, 110.51727736,\n", + " 2.65094349, 144.27230078, 185.75697454, 10.81034621,\n", + " 462.83508143, 566.27203227, -5.53330574, 125.27478433,\n", + " 185.59939781, 168.88392753, 317.09608594, 171.92507502,\n", + " 22.91712564, 167.36531564, 28.04318899, 44.46072362,\n", + " 97.92748209, 13.34154912, 0.66046295, 131.74620326,\n", + " 431.8011814 , 270.05259063, 22.60712417, 34.93332853,\n", + " 33.95914936, 19.73818115])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "poly_reg_y_predicted" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "adf5d45e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fitted: 457.33663363825696\n", + "true: 466.8851720637676\n" + ] + } + ], + "source": [ + "i = 8\n", + "fitted_y = 14.12 + 3.62 * X_test[i][0] + -1.09 * X_test[i][1] + 1.90 * X_test[i][2] + 0.02 * X_test[i][3] + 0.01 * X_test[i][4]\n", + "true_y = list(y_test)[i]\n", + "print('fitted:', fitted_y)\n", + "print('true:', true_y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65154120", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "base" + }, + "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.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}