{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "Kkolejna część zajęć będzie wprowadzeniem do drugiej, szeroko używanej biblioteki w Pythonie: `sklearn`. Zajęcia będą miały charaktere case-study poprzeplatane zadaniami do wykonania. Zacznijmy od załadowania odpowiednich bibliotek." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "scrolled": true }, "outputs": [], "source": [ "# ! pip install matplotlib" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "\n", "%matplotlib inline" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Zacznijmy od załadowania danych. Na dzisiejszych zajęciach będziemy korzystać z danych z portalu [gapminder.org](https://www.gapminder.org/data/)." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [], "source": [ "df = pd.read_csv('gapminder.csv', index_col=0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Dane zawierają różne informacje z większość państw świata (z roku 2008). Poniżej znajduje się opis kolumn:\n", " * female_BMI - średnie BMI u kobiet\n", " * male_BMI - średnie BMI u mężczyzn\n", " * gdp - PKB na obywatela\n", " * population - wielkość populacji\n", " * under5mortality - wskaźnik śmiertelności dzieni pon. 5 roku życia (na 1000 urodzonych dzieci)\n", " * life_expectancy - średnia długość życia\n", " * fertility - wskaźnik dzietności" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**zad. 1**\n", "Na podstawie danych zawartych w `df` odpowiedz na następujące pytania:\n", " * Jaki był współczynniki dzietności w Polsce w 2018?\n", " * W którym kraju ludzie żyją najdłużej?\n", " * Z ilu krajów zostały zebrane dane?" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "175" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.head(10)\n", "\n", "df.loc['Poland', 'fertility']\n", "df[df['life_expectancy'].max() == df['life_expectancy']]\n", "len(df.index)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**zad. 2** Stwórz kolumnę `gdp_log`, która powstanie z kolumny `gdp` poprzez zastowanie funkcji `log` (logarytm). \n", "\n", "Hint 1: Wykorzystaj funkcję `apply` (https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.apply.html#pandas.Series.apply).\n", "\n", "Hint 2: Wykorzystaj fukcję `log` z pakietu `np`." ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "df['gdp_log'] = df['gdp'].apply(np.log)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Naszym zadaniem będzie oszacowanie długości życia (kolumna `life_expectancy`) na podstawie pozostałych zmiennych. Na samym początku, zastosujemy regresje jednowymiarową na `fertility`." ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Y shape: (175,)\n", "X shape: (175,)\n" ] } ], "source": [ "y = df['life_expectancy'].values\n", "X = df['fertility'].values\n", "\n", "print(\"Y shape:\", y.shape)\n", "print(\"X shape:\", X.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Będziemy korzystać z gotowej implementacji regreji liniowej z pakietu sklearn. Żeby móc wykorzystać, musimy napierw zmienić shape na dwuwymiarowy." ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Y shape: (175, 1)\n", "X shape: (175, 1)\n" ] } ], "source": [ "y = y.reshape(-1, 1)\n", "X = X.reshape(-1, 1)\n", "\n", "print(\"Y shape:\", y.shape)\n", "print(\"X shape:\", X.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Jeszcze przed właściwą analizą, narysujmy wykres i zobaczny czy istnieje \"wizualny\" związek pomiędzy kolumnami." ] }, { "cell_type": "code", "execution_count": 98, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 98, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "df.plot.scatter('gdp_log', 'gdp')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**zad. 3** Zaimportuj `LinearRegression` z pakietu `sklearn.linear_model`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Tworzymy obiekt modelu regresji liniowej." ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [], "source": [ "from sklearn.linear_model import LinearRegression\n", "model = LinearRegression()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Trening modelu ogranicza się do wywołania metodu `fit`, która przyjmuje dwa argumenty:" ] }, { "cell_type": "code", "execution_count": 36, "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": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "model.fit(X, y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Współczynniki modelu:" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Wyraz wolny (bias): [83.2025629]\n", "Współczynniki cech: [[-4.41400624]]\n" ] } ], "source": [ "print(\"Wyraz wolny (bias):\", model.intercept_)\n", "print(\"Współczynniki cech:\", model.coef_)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**zad. 4** Wytrenuj nowy model `model2`, który będzie jako X przyjmie kolumnę `gdp_log`. Wyświetl parametry nowego modelu." ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Wyraz wolny (bias): [20.24520889]\n", "Współczynniki cech: [[5.47719379]]\n" ] } ], "source": [ "y = df['life_expectancy'].values\n", "X = df['gdp_log'].values\n", "\n", "y = y.reshape(-1, 1)\n", "X = X.reshape(-1, 1)\n", "\n", "model.fit(X, y)\n", "\n", "print(\"Wyraz wolny (bias):\", model.intercept_)\n", "print(\"Współczynniki cech:\", model.coef_)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mając wytrenowany model możemy wykorzystać go do predykcji. Wystarczy wywołać metodę `predict`." ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "input: 7.1785454837637\t predicted: 59.56349361537759\t expected: 52.8\n", "input: 9.064620717626777\t predicted: 69.89389316839483\t expected: 76.8\n", "input: 9.418492105471156\t predicted: 71.83211533534711\t expected: 75.5\n", "input: 8.86827250899781\t predicted: 68.81845597997369\t expected: 56.7\n", "input: 10.155646068918863\t predicted: 75.86965044411781\t expected: 75.5\n" ] } ], "source": [ "X_test = X[:5,:]\n", "y_test = y[:5,:]\n", "output = model.predict(X_test)\n", "\n", "for i in range(5):\n", " print(\"input: {}\\t predicted: {}\\t expected: {}\".format(X_test[i,0], output[i,0], y_test[i,0]))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Sprawdzenie jakości modelu - metryki: $MSE$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Istnieją 3 metryki, które określają jak dobry jest nasz model:\n", " * $MSE$: [błąd średnio-kwadratowy](https://pl.wikipedia.org/wiki/B%C5%82%C4%85d_%C5%9Bredniokwadratowy) \n", " * $RMSE = \\sqrt{MSE}$" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Root Mean Squared Error: 5.542126033117308\n" ] } ], "source": [ "from sklearn.metrics import mean_squared_error\n", "\n", "rmse = np.sqrt(mean_squared_error(y, model.predict(X)))\n", "print(\"Root Mean Squared Error: {}\".format(rmse))" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "R^2: 0.768485708231896\n", "Root Mean Squared Error: 4.108807300711791\n" ] } ], "source": [ "# Import necessary modules\n", "from sklearn.linear_model import LinearRegression\n", "from sklearn.metrics import mean_squared_error\n", "from sklearn.model_selection import train_test_split\n", "\n", "# Create training and test sets\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.30, random_state=42)\n", "\n", "# Create the regressor: reg_all\n", "reg_all = LinearRegression() \n", "\n", "# Fit the regressor to the training data\n", "reg_all.fit(X_train, y_train)\n", "\n", "# Predict on the test data: y_pred\n", "y_pred = reg_all.predict(X_test)\n", "\n", "# Compute and print R^2 and RMSE\n", "print(\"R^2: {}\".format(reg_all.score(X_test, y_test)))\n", "rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n", "print(\"Root Mean Squared Error: {}\".format(rmse))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Regresja wielu zmiennych" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Model regresji liniowej wielu zmiennych nie różni się istotnie od modelu jednej zmiennej. Np. chcąc zbudować model oparty o dwie kolumny: `fertility` i `gdp` wystarczy zmienić X (cechy wejściowe):" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(175, 2)\n", "Wyraz wolny (bias): [78.39388437]\n", "Współczynniki cech: [[-3.68816683e+00 1.38298454e-04]]\n", "Root Mean Squared Error: 4.347105512793037\n" ] } ], "source": [ "X = df[['fertility', 'gdp']]\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.30, random_state=42)\n", "\n", "print(X.shape)\n", "\n", "model_mv = LinearRegression()\n", "model_mv.fit(X_train, y_train)\n", "\n", "print(\"Wyraz wolny (bias):\", model_mv.intercept_)\n", "print(\"Współczynniki cech:\", model_mv.coef_)\n", "\n", "y_pred = model_mv.predict(X_test)\n", "\n", "rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n", "print(\"Root Mean Squared Error: {}\".format(rmse))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**zad. 7** \n", " * Zbuduj model regresji liniowej, która oszacuje wartność kolumny `life_expectancy` na podstawie pozostałych kolumn.\n", " * Wyświetl współczynniki modelu.\n", " * Oblicz wartości metryki rmse na zbiorze trenującym.\n", " " ] }, { "cell_type": "code", "execution_count": 87, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Wyraz wolny (bias): 51.77966340645703\n", "Współczynniki cech: [-1.26558913e+00 1.58457647e+00 -1.19465585e-05 8.99682207e-10\n", " -1.32027358e-01 3.09413223e-01 1.74214537e+00]\n", "Root Mean Sqared Error: 3.42188778846474\n" ] } ], "source": [ "from sklearn.linear_model import LogisticRegression, LinearRegression, LogisticRegressionCV\n", "from sklearn.model_selection import train_test_split\n", "\n", "X = df.drop('life_expectancy', axis='columns')\n", "y = df['life_expectancy']\n", "\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3)\n", "\n", "model = LinearRegression()\n", "model.fit(X_train, y_train)\n", "\n", "print(\"Wyraz wolny (bias):\", model.intercept_)\n", "print(\"Współczynniki cech:\", model.coef_)\n", "\n", "y_pred = model.predict(X_test)\n", "\n", "rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n", "print(f\"Root Mean Sqared Error: {rmse}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**zad. 6**\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ " Zaimplementuj metrykę $RMSE$ jako fukcję rmse (szablon poniżej). Fukcja rmse przyjmuje dwa parametry typu list i ma zwrócić wartość metryki $RMSE$ ." ] }, { "cell_type": "code", "execution_count": 96, "metadata": {}, "outputs": [ { "ename": "ValueError", "evalue": "Found input variables with inconsistent numbers of samples: [175, 176]", "output_type": "error", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", "\u001b[1;32mj:\\Python\\2023-programowanie-w-pythonie\\zajecia3\\sklearn cz. 1.ipynb Cell 39\u001b[0m line \u001b[0;36m2\n\u001b[0;32m 26\u001b[0m expected\u001b[39m.\u001b[39mappend(\u001b[39m1\u001b[39m)\n\u001b[0;32m 28\u001b[0m \u001b[39m# print(rmse(predicted,expected))\u001b[39;00m\n\u001b[1;32m---> 29\u001b[0m \u001b[39mprint\u001b[39m(np\u001b[39m.\u001b[39msqrt(mean_squared_error(predicted, expected)))\n", "File \u001b[1;32mc:\\software\\python3\\lib\\site-packages\\sklearn\\utils\\_param_validation.py:211\u001b[0m, in \u001b[0;36mvalidate_params..decorator..wrapper\u001b[1;34m(*args, **kwargs)\u001b[0m\n\u001b[0;32m 205\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m 206\u001b[0m \u001b[39mwith\u001b[39;00m config_context(\n\u001b[0;32m 207\u001b[0m skip_parameter_validation\u001b[39m=\u001b[39m(\n\u001b[0;32m 208\u001b[0m prefer_skip_nested_validation \u001b[39mor\u001b[39;00m global_skip_validation\n\u001b[0;32m 209\u001b[0m )\n\u001b[0;32m 210\u001b[0m ):\n\u001b[1;32m--> 211\u001b[0m \u001b[39mreturn\u001b[39;00m func(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[0;32m 212\u001b[0m \u001b[39mexcept\u001b[39;00m InvalidParameterError \u001b[39mas\u001b[39;00m e:\n\u001b[0;32m 213\u001b[0m \u001b[39m# When the function is just a wrapper around an estimator, we allow\u001b[39;00m\n\u001b[0;32m 214\u001b[0m \u001b[39m# the function to delegate validation to the estimator, but we replace\u001b[39;00m\n\u001b[0;32m 215\u001b[0m \u001b[39m# the name of the estimator by the name of the function in the error\u001b[39;00m\n\u001b[0;32m 216\u001b[0m \u001b[39m# message to avoid confusion.\u001b[39;00m\n\u001b[0;32m 217\u001b[0m msg \u001b[39m=\u001b[39m re\u001b[39m.\u001b[39msub(\n\u001b[0;32m 218\u001b[0m \u001b[39mr\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mparameter of \u001b[39m\u001b[39m\\\u001b[39m\u001b[39mw+ must be\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[0;32m 219\u001b[0m \u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mparameter of \u001b[39m\u001b[39m{\u001b[39;00mfunc\u001b[39m.\u001b[39m\u001b[39m__qualname__\u001b[39m\u001b[39m}\u001b[39;00m\u001b[39m must be\u001b[39m\u001b[39m\"\u001b[39m,\n\u001b[0;32m 220\u001b[0m \u001b[39mstr\u001b[39m(e),\n\u001b[0;32m 221\u001b[0m )\n", "File \u001b[1;32mc:\\software\\python3\\lib\\site-packages\\sklearn\\metrics\\_regression.py:474\u001b[0m, in \u001b[0;36mmean_squared_error\u001b[1;34m(y_true, y_pred, sample_weight, multioutput, squared)\u001b[0m\n\u001b[0;32m 404\u001b[0m \u001b[39m@validate_params\u001b[39m(\n\u001b[0;32m 405\u001b[0m {\n\u001b[0;32m 406\u001b[0m \u001b[39m\"\u001b[39m\u001b[39my_true\u001b[39m\u001b[39m\"\u001b[39m: [\u001b[39m\"\u001b[39m\u001b[39marray-like\u001b[39m\u001b[39m\"\u001b[39m],\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 415\u001b[0m y_true, y_pred, \u001b[39m*\u001b[39m, sample_weight\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m, multioutput\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39muniform_average\u001b[39m\u001b[39m\"\u001b[39m, squared\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m\n\u001b[0;32m 416\u001b[0m ):\n\u001b[0;32m 417\u001b[0m \u001b[39m \u001b[39m\u001b[39m\"\"\"Mean squared error regression loss.\u001b[39;00m\n\u001b[0;32m 418\u001b[0m \n\u001b[0;32m 419\u001b[0m \u001b[39m Read more in the :ref:`User Guide `.\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 472\u001b[0m \u001b[39m 0.825...\u001b[39;00m\n\u001b[0;32m 473\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[1;32m--> 474\u001b[0m y_type, y_true, y_pred, multioutput \u001b[39m=\u001b[39m _check_reg_targets(\n\u001b[0;32m 475\u001b[0m y_true, y_pred, multioutput\n\u001b[0;32m 476\u001b[0m )\n\u001b[0;32m 477\u001b[0m check_consistent_length(y_true, y_pred, sample_weight)\n\u001b[0;32m 478\u001b[0m output_errors \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39maverage((y_true \u001b[39m-\u001b[39m y_pred) \u001b[39m*\u001b[39m\u001b[39m*\u001b[39m \u001b[39m2\u001b[39m, axis\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m, weights\u001b[39m=\u001b[39msample_weight)\n", "File \u001b[1;32mc:\\software\\python3\\lib\\site-packages\\sklearn\\metrics\\_regression.py:99\u001b[0m, in \u001b[0;36m_check_reg_targets\u001b[1;34m(y_true, y_pred, multioutput, dtype)\u001b[0m\n\u001b[0;32m 65\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_check_reg_targets\u001b[39m(y_true, y_pred, multioutput, dtype\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mnumeric\u001b[39m\u001b[39m\"\u001b[39m):\n\u001b[0;32m 66\u001b[0m \u001b[39m \u001b[39m\u001b[39m\"\"\"Check that y_true and y_pred belong to the same regression task.\u001b[39;00m\n\u001b[0;32m 67\u001b[0m \n\u001b[0;32m 68\u001b[0m \u001b[39m Parameters\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 97\u001b[0m \u001b[39m correct keyword.\u001b[39;00m\n\u001b[0;32m 98\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[1;32m---> 99\u001b[0m check_consistent_length(y_true, y_pred)\n\u001b[0;32m 100\u001b[0m y_true \u001b[39m=\u001b[39m check_array(y_true, ensure_2d\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m, dtype\u001b[39m=\u001b[39mdtype)\n\u001b[0;32m 101\u001b[0m y_pred \u001b[39m=\u001b[39m check_array(y_pred, ensure_2d\u001b[39m=\u001b[39m\u001b[39mFalse\u001b[39;00m, dtype\u001b[39m=\u001b[39mdtype)\n", "File \u001b[1;32mc:\\software\\python3\\lib\\site-packages\\sklearn\\utils\\validation.py:409\u001b[0m, in \u001b[0;36mcheck_consistent_length\u001b[1;34m(*arrays)\u001b[0m\n\u001b[0;32m 407\u001b[0m uniques \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39munique(lengths)\n\u001b[0;32m 408\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mlen\u001b[39m(uniques) \u001b[39m>\u001b[39m \u001b[39m1\u001b[39m:\n\u001b[1;32m--> 409\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[0;32m 410\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mFound input variables with inconsistent numbers of samples: \u001b[39m\u001b[39m%r\u001b[39;00m\u001b[39m\"\u001b[39m\n\u001b[0;32m 411\u001b[0m \u001b[39m%\u001b[39m [\u001b[39mint\u001b[39m(l) \u001b[39mfor\u001b[39;00m l \u001b[39min\u001b[39;00m lengths]\n\u001b[0;32m 412\u001b[0m )\n", "\u001b[1;31mValueError\u001b[0m: Found input variables with inconsistent numbers of samples: [175, 176]" ] } ], "source": [ "def rmse(expected, predicted):\n", " \"\"\"\n", " argumenty:\n", " expected (type: list): poprawne wartości\n", " predicted (type: list): oszacowanie z modelu\n", " \"\"\"\n", "\n", " if len(expected) != len(predicted):\n", " raise ValueError(\"Lists have to be equal length, can't proceed.\")\n", "\n", " mse = 0\n", " for i in range(len(expected)):\n", " mse += pow((expected[i] - predicted[i]),2)\n", " return np.sqrt(mse/len(expected))\n", " \n", " \n", "\n", "y = df['life_expectancy'].values\n", "X = df[['fertility', 'gdp']].values\n", "\n", "test_model = LinearRegression()\n", "test_model.fit(X, y)\n", "\n", "predicted = list(test_model.predict(X))\n", "expected = list(y)\n", "# expected.append(1)\n", "\n", "print(rmse(predicted,expected))\n", "print(np.sqrt(mean_squared_error(predicted, expected)))\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.10.11" } }, "nbformat": 4, "nbformat_minor": 2 }