diff --git a/notebooks/examples/linear_regression.ipynb b/notebooks/examples/linear_regression.ipynb index b6212104eb65765d5047a861b385d582c280feaa..8adf9d7baf57b067c02130f1520e0ba56a32a7b4 100644 --- a/notebooks/examples/linear_regression.ipynb +++ b/notebooks/examples/linear_regression.ipynb @@ -2,40 +2,59 @@ "cells": [ { "cell_type": "markdown", - "id": "18054401", - "metadata": {}, + "metadata": { + "collapsed": false + }, "source": [ - "# Linear Regression" + "# Linear Regression\n", + "\n", + "In this notebook we will take a look at an example of a linear and polynomial regression.\n", + "\n", + "We will do a bunch of preprocessing to see how different problems can be solved in a typical regression problem.\n", + "Afterwards we will train the algorithm and try to find the best polynomial degree possible. The reason for this is to get the lowest rmse possible which will result in better predictions." ] }, { "cell_type": "code", "execution_count": 1, - "id": "3b64dd57-d529-4190-bf18-a03301cf293e", - "metadata": {}, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "import pandas as pd\n", "import numpy as np\n", "import sklearn\n", "from sklearn import linear_model\n", - "import matplotlib.pyplot as plt" + "import matplotlib.pyplot as plt\n", + "from sklearn.preprocessing import MinMaxScaler\n", + "from sklearn.pipeline import Pipeline\n", + "import matplotlib.pyplot as plt\n", + "from sklearn.metrics import mean_squared_error, r2_score" ] }, { "cell_type": "markdown", - "id": "e02b8b4e-55cf-4616-8885-ea66cb27a9d9", - "metadata": {}, + "metadata": { + "collapsed": false + }, "source": [ - "### Read the csv file into dataframe\n", - "The following instruction (data.head()) allows us to see the structure of the dataframe" + "Read the csv file into a dataframe.\n", + "The data.head() function will show the first few entries of the dataset and give us a little insight into the kind of data each column contains." ] }, { "cell_type": "code", "execution_count": 2, - "id": "f992c0ec-cdc2-4c0f-8fa6-baaef0b929a2", - "metadata": {}, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -142,21 +161,125 @@ ] }, { - "cell_type": "markdown", - "id": "90bd3b1e-dfc1-4eee-a2ef-21db77cbf1c2", + "cell_type": "code", + "execution_count": 3, + "id": "509d93f0", "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "<class 'pandas.core.frame.DataFrame'>\n", + "RangeIndex: 1338 entries, 0 to 1337\n", + "Data columns (total 7 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 age 1338 non-null int64 \n", + " 1 sex 1338 non-null object \n", + " 2 bmi 1338 non-null float64\n", + " 3 children 1338 non-null int64 \n", + " 4 smoker 1338 non-null object \n", + " 5 region 1338 non-null object \n", + " 6 charges 1338 non-null float64\n", + "dtypes: float64(2), int64(2), object(3)\n", + "memory usage: 73.3+ KB\n" + ] + } + ], + "source": [ + "df.info()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "The next step is for demonstration purposes only. Because many datasets are incomplete we are going to introduce some missing data here to take a look at how you can handle them. Since our dataset has no missing data, we will intentionally drop some values." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "for x in range(50):\n", + " df.loc[x,\"age\"] = np.NaN" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "As we can see, the column age has 1288 non-Null values now. That means the column is missing 50 values now." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "<class 'pandas.core.frame.DataFrame'>\n", + "RangeIndex: 1338 entries, 0 to 1337\n", + "Data columns (total 7 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 age 1288 non-null float64\n", + " 1 sex 1338 non-null object \n", + " 2 bmi 1338 non-null float64\n", + " 3 children 1338 non-null int64 \n", + " 4 smoker 1338 non-null object \n", + " 5 region 1338 non-null object \n", + " 6 charges 1338 non-null float64\n", + "dtypes: float64(3), int64(1), object(3)\n", + "memory usage: 73.3+ KB\n" + ] + } + ], + "source": [ + "df.info()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, "source": [ - "If we want to be able to do the linear regression we have 2 possibilities:\n", + "If we want to be able to do the linear regression we have 2 possibilities\n", "\n", - "- 1. getting rid of all the non numerical data.\n", - "- 2. the better option, which we also use below, is converting the categorical data into numerical data" + "The first one is getting rid of all the data which are non-numerical values. The second and much better option which we also use below is converting the categorical data into numbers.\n", + "Also we will fill our missing values with the mean value of this column. Otherwise we can't proceed with our linear regression because the algorithm can not work with NaN values." ] }, { "cell_type": "code", - "execution_count": 3, - "id": "4baa1c56-4d4c-40f3-98d9-4f15987b6626", - "metadata": {}, + "execution_count": 6, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "data": { @@ -191,7 +314,7 @@ " <tbody>\n", " <tr>\n", " <th>0</th>\n", - " <td>19</td>\n", + " <td>39.29736</td>\n", " <td>1</td>\n", " <td>27.900</td>\n", " <td>0</td>\n", @@ -201,7 +324,7 @@ " </tr>\n", " <tr>\n", " <th>1</th>\n", - " <td>18</td>\n", + " <td>39.29736</td>\n", " <td>0</td>\n", " <td>33.770</td>\n", " <td>1</td>\n", @@ -211,7 +334,7 @@ " </tr>\n", " <tr>\n", " <th>2</th>\n", - " <td>28</td>\n", + " <td>39.29736</td>\n", " <td>0</td>\n", " <td>33.000</td>\n", " <td>3</td>\n", @@ -221,7 +344,7 @@ " </tr>\n", " <tr>\n", " <th>3</th>\n", - " <td>33</td>\n", + " <td>39.29736</td>\n", " <td>0</td>\n", " <td>22.705</td>\n", " <td>0</td>\n", @@ -231,7 +354,7 @@ " </tr>\n", " <tr>\n", " <th>4</th>\n", - " <td>32</td>\n", + " <td>39.29736</td>\n", " <td>0</td>\n", " <td>28.880</td>\n", " <td>0</td>\n", @@ -244,102 +367,478 @@ "</div>" ], "text/plain": [ - " age sex bmi children smoker region charges\n", - "0 19 1 27.900 0 1 1 16884.92400\n", - "1 18 0 33.770 1 0 0 1725.55230\n", - "2 28 0 33.000 3 0 0 4449.46200\n", - "3 33 0 22.705 0 0 3 21984.47061\n", - "4 32 0 28.880 0 0 3 3866.85520" + " age sex bmi children smoker region charges\n", + "0 39.29736 1 27.900 0 1 1 16884.92400\n", + "1 39.29736 0 33.770 1 0 0 1725.55230\n", + "2 39.29736 0 33.000 3 0 0 4449.46200\n", + "3 39.29736 0 22.705 0 0 3 21984.47061\n", + "4 39.29736 0 28.880 0 0 3 3866.85520" ] }, - "execution_count": 3, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "df[\"age\"] = df[\"age\"].fillna(df[\"age\"].mean())\n", "df[\"sex\"] = df[\"sex\"].map({'male': 0, 'female': 1})\n", "df[\"smoker\"] = df[\"smoker\"].map({'no': 0, 'yes': 1})\n", - "df[\"region\"] = df[\"region\"].map({'southeast': 0, 'southwest': 1,'northeast': 2, 'northwest': 3})\n", + "df[\"region\"] = df[\"region\"].map({'southeast': 0,\n", + " 'southwest': 1,'northeast': 2, 'northwest': 3})\n", "df.head()" ] }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "<class 'pandas.core.frame.DataFrame'>\n", + "RangeIndex: 1338 entries, 0 to 1337\n", + "Data columns (total 7 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 age 1338 non-null float64\n", + " 1 sex 1338 non-null int64 \n", + " 2 bmi 1338 non-null float64\n", + " 3 children 1338 non-null int64 \n", + " 4 smoker 1338 non-null int64 \n", + " 5 region 1338 non-null int64 \n", + " 6 charges 1338 non-null float64\n", + "dtypes: float64(3), int64(4)\n", + "memory usage: 73.3 KB\n" + ] + } + ], + "source": [ + "df.info()" + ] + }, { "cell_type": "markdown", - "id": "b118cd4a-c6b5-4572-af00-47e0a31659be", - "metadata": {}, + "metadata": { + "collapsed": false + }, "source": [ - "## Seperating our dataframe\n", - "We have converted the dataframe to one with only numerical data. But furthermore we need to seperate our dataframe into 2 parts, where the first part is the dataframe excluding the value we want to predict(\"charges\") with the given data. And the other part is just the rest." + "Now that our data has been converted and no longer has zero values, we will plot the mean of our dependent variable as a function of each independent variable." ] }, { "cell_type": "code", - "execution_count": 4, - "id": "0eae79fd-622d-4c38-b52e-5ce915808471", - "metadata": {}, + "execution_count": 8, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_5028/2186008743.py:2: FutureWarning: In a future version of pandas all arguments of DataFrame.drop except for the argument 'labels' will be keyword-only\n", - " df_X = np.array(df.drop([predict],1))\n" - ] + "data": { + "text/plain": [ + "<AxesSubplot:xlabel='smoker'>" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df.groupby(\"smoker\")[\"charges\"].mean().plot(kind='bar')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<AxesSubplot:xlabel='children'>" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df.groupby(\"children\")[\"charges\"].mean().plot(kind='bar')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<AxesSubplot:xlabel='region'>" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df.groupby(\"region\")[\"charges\"].mean().plot(kind='bar')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<AxesSubplot:xlabel='bmi'>" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df.groupby(\"bmi\")[\"charges\"].mean().plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<AxesSubplot:xlabel='sex'>" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "df.groupby(\"sex\")[\"charges\"].mean().plot(kind='bar')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "<AxesSubplot:xlabel='age'>" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], + "source": [ + "df.groupby(\"age\")[\"charges\"].mean().plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "The reason for the plots above is that we want to get an understanding about the data we are working with and try to figure out which features are the most important for the regression algorithm.\n", + "The columns `age`, `smoker` and `bmi` have a huge impact on our dependent variable while region and children have less of an impact. The column \"sex\" doesn't seem to have much impact on our \"expenses\" variable and is not necessary. That's why we are dropping the \"sex\" column below" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "## Preprocessing\n", + "We already have a converted dataframe with only integer numbers which is great.\n", + "Next we will define our prediction target and the features which will be used for the prediction.\n", + "We will also scale the features so that a feature which has a larger number does not have more of an impact than features with smaller numbers. For this we will use the MinMaxScaler." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "6fbef232", + "metadata": {}, + "outputs": [], "source": [ "predict = \"charges\"\n", - "df_X = np.array(df.drop([predict],1))\n", - "df_Y = np.array(df[predict])" + "features = [\"age\",\"smoker\",\"bmi\",\"children\",\"region\"]\n", + "\n", + "scaler = MinMaxScaler()\n", + "df[features] = scaler.fit_transform(df[features])" ] }, { "cell_type": "markdown", - "id": "790f7ac1-3e9c-4545-82c6-6bd33e0b5d5f", + "id": "8e4bb356", "metadata": {}, "source": [ - "The next step is to split the data even more. The data is going to be split in 4 different parts. 2 training datasets (X_Train and Y_Train) and 2 test datasets(X_Test,Y_Test). Our train dataset is obviously to train our model while the test dataset is created to validate the accuracy of our model afterwards. If the split is done to assure that our model is actually working and not just overfitting our training data." + "We will split the data into a training and a test dataset. The training dataset is used for training the model and the test dataset is used to verify the predictions.\n", + "If we didn't split the data, we wouldn't be able to assure that our model is actually working and not just overfitting our training data." ] }, { "cell_type": "code", - "execution_count": 5, - "id": "c9366399-5fc5-4d8a-b616-aae9b57da2f8", + "execution_count": 15, + "id": "3bf48dc4", "metadata": {}, "outputs": [], "source": [ - "X_Train, X_Test, Y_Train, Y_Test = sklearn.model_selection.train_test_split(df_X,df_Y,test_size=0.20)\n", - "linear = linear_model.LinearRegression()\n", - "linear.fit(X_Train,Y_Train)\n", - "predictions = linear.predict(X_Test)\n", - "acc = linear.score(X_Test,Y_Test)" + "train, test = sklearn.model_selection.train_test_split(df,test_size=0.1,random_state=42)" ] }, { "cell_type": "markdown", - "id": "d26b635e-2b40-48f8-a66c-85bd70a9308a", - "metadata": {}, + "metadata": { + "collapsed": false + }, "source": [ - "The last step is to simply output the data to see the result" + "In the next step we are going to split the data into `X` and `y` sets. The `X` datasets are filled with the features used to predict the data in the `y` datasets." ] }, { "cell_type": "code", - "execution_count": 6, - "id": "87e79d67-e2a3-41bd-a1c0-2ca5576de19c", + "execution_count": 16, + "id": "99bcbdbc", "metadata": {}, + "outputs": [], + "source": [ + "X_train = train[features]\n", + "y_train = train[predict]\n", + "X_test = test[features]\n", + "y_test = test[predict]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "Now we are going to train our model using the scaled and preprocessed training data. To see how our model weighed each column we are printing the coefficients and the intercept afterwards." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0.7658017063596445\n" + "linear coeffecients for: age, smoker, bmi, children, region\n", + "[11918.86648376 23898.14003977 12188.17064225 2244.89376338\n", + " 761.84404289]\n", + "intercept: -2758.2257893886454\n" + ] + } + ], + "source": [ + "linear = linear_model.LinearRegression()\n", + "linear.fit(X_train,y_train)\n", + "predictions = linear.predict(X_test)\n", + "print(\"linear coeffecients for: age, smoker, bmi, children, region\")\n", + "print(linear.coef_)\n", + "print(\"intercept: \", linear.intercept_)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "With the coefficients and intercept we can demonstrate how the model predicts the target variable internally using the formula which you can find in the mdbook linear regression chapter. To proof that this is the same calculation we will also let the model predict the same data." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hand predicted value : 7591.985875541097\n", + "model predicted value : 7591.985875541097\n", + "actual value : 6186.127\n" + ] + } + ], + "source": [ + "hand_predicted_value = linear.intercept_ + (X_train.iat[100,0] * linear.coef_[0]) + (X_train.iat[100,1] * linear.coef_[1]) + (X_train.iat[100,2] * linear.coef_[2]) + (X_train.iat[100,3] * linear.coef_[3]) + (X_train.iat[100,4] * linear.coef_[4])\n", + "tmp = pd.DataFrame(X_train.iloc[100]).transpose()\n", + "model_predicted_value = linear.predict(tmp)\n", + "print(\"hand predicted value : \", hand_predicted_value)\n", + "print(\"model predicted value : \", model_predicted_value[0])\n", + "print(\"actual value : \", y_train[100])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "To see how our model performed on the training data we are calculating the root mean squared error (rmse) and the accuracy to see the performance. Also we are adding a plot with the first 20 predictions compared to the actual values to get a visual understanding of how good our prediction is." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.766329065180451\n", + "Root mean squared error : 5677.688231925713\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "<Figure size 432x288 with 1 Axes>" ] @@ -351,20 +850,148 @@ } ], "source": [ + "acc = linear.score(X_test,y_test)\n", "print(acc)\n", - "plt.plot(Y_Test[0:20])\n", - "plt.plot(predictions[0:20])\n", - "plt.legend([\"this is test\", \"this is prediction\"])\n", + "rmse = np.sqrt(mean_squared_error(y_test,predictions))\n", + "print(\"Root mean squared error : \", rmse)\n", + "x_axis = range(0,20)\n", + "plt.plot(x_axis, y_test[0:20])\n", + "plt.plot(x_axis, predictions[0:20])\n", + "plt.legend([\"true values\", \"predicted values\"])\n", "plt.show()" ] }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "Now we will try to see if our model is in a linear relation or a polynomial relation. To be able to answer this question we will plot different polynomial degrees and their respective rmse to see which polynomial degree is best for predicting our data." + ] + }, { "cell_type": "code", - "execution_count": null, - "id": "279cde9b-e2d2-40a8-b632-af97e63bd08c", - "metadata": {}, + "execution_count": 20, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[5677.688231925711, 4364.019399068003, 4224.0557359453915, 5199.253242637651, 5585.951466471735]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.preprocessing import PolynomialFeatures\n", + "plt.title(\"RMSE vs. Polynomial Degree\")\n", + "plt.ylabel(\"RMSE\")\n", + "plt.xlabel(\"degree\")\n", + "plt.grid()\n", + "rmselist = []\n", + "for x in range(5):\n", + " polynomial_features= PolynomialFeatures(degree=x+1)\n", + " x_poly_train = polynomial_features.fit_transform(X_train)\n", + " x_poly_test = polynomial_features.fit_transform(X_test)\n", + " model = linear_model.LinearRegression()\n", + "\n", + " model.fit(x_poly_train, y_train)\n", + " y_poly_pred = model.predict(x_poly_test)\n", + " rmse = np.sqrt(mean_squared_error(y_test,y_poly_pred))\n", + " rmselist.append(rmse)\n", + "print(rmselist)\n", + "plt.plot((1,2,3,4,5),rmselist)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": false + }, + "source": [ + "Based on the plot we can see that the best polynomial degree for our data is 3. We will use this degree and plot the first 20 datapoints again.\n", + "Since Linear Regression has a score function which calculates the r2 score but polynomial features doesn't have a score function, we need to include r2 score to see our accuracy improvement." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], - "source": [] + "source": [ + "polynomial_features= PolynomialFeatures(degree=3)\n", + "x_poly_train = polynomial_features.fit_transform(X_train)\n", + "x_poly_test = polynomial_features.fit_transform(X_test)\n", + "model = linear_model.LinearRegression()\n", + "\n", + "model.fit(x_poly_train, y_train)\n", + "y_poly_pred = model.predict(x_poly_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "rmse: 4224.0557359453915\n", + "r2 score: 0.8706635627502789\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "rmse = np.sqrt(mean_squared_error(y_test,y_poly_pred))\n", + "print(\"rmse: \",rmse)\n", + "print(\"r2 score: \", r2_score(y_test,y_poly_pred))\n", + "plt.plot(x_axis,y_test[0:20])\n", + "plt.plot(x_axis,y_poly_pred[0:20])\n", + "plt.legend([\"this is test\", \"this is prediction\"])\n", + "plt.show()" + ] } ], "metadata": { @@ -383,7 +1010,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.2" + "version": "3.9.7" } }, "nbformat": 4,