{ "cells": [ { "cell_type": "markdown", "id": "2e5de355-6204-4229-b741-731d6e43938f", "metadata": { "id": "2e5de355-6204-4229-b741-731d6e43938f" }, "source": [ "# Práctico 3 - Sesgo & Varianza" ] }, { "cell_type": "markdown", "id": "3993bd49-18ac-411a-a57b-c9af7e0bc77d", "metadata": { "id": "3993bd49-18ac-411a-a57b-c9af7e0bc77d" }, "source": [ "## Imports" ] }, { "cell_type": "code", "execution_count": null, "id": "6632abaa-18c4-417b-a987-386d7fa0e2a2", "metadata": { "id": "6632abaa-18c4-417b-a987-386d7fa0e2a2" }, "outputs": [], "source": [ "import numpy as np\n", "np.set_printoptions(formatter={'float': lambda x: \"{0:0.5f}\".format(x)})\n", "\n", "# Visualizations\n", "import matplotlib.pyplot as plt\n", "\n", "# Machine learning\n", "import sklearn\n", "\n", "# Regression\n", "from sklearn.linear_model import LinearRegression\n", "\n", "# Preprocessing\n", "from sklearn.preprocessing import PolynomialFeatures\n", "from sklearn.preprocessing import StandardScaler\n", "\n", "# Metrics\n", "from sklearn.metrics import mean_squared_error\n", "\n", "# Data analysis and manipulation\n", "import pandas as pd\n", "pd.set_option('display.precision', 5) # 5 decimales" ] }, { "cell_type": "markdown", "id": "e929773c-0cd2-438c-9f1a-67b0ae09e329", "metadata": { "id": "e929773c-0cd2-438c-9f1a-67b0ae09e329" }, "source": [ "## MSE verdadero vs. MSE en test" ] }, { "cell_type": "markdown", "id": "38a0e65c", "metadata": { "id": "38a0e65c" }, "source": [ "### Función de regresión verdadera" ] }, { "cell_type": "markdown", "id": "e7e99f7a-b39e-4803-8c81-6b9dab04afbc", "metadata": { "id": "e7e99f7a-b39e-4803-8c81-6b9dab04afbc" }, "source": [ "Vamos a trabajar con el ejemplo del rendimiento medio del cultivo de papas en función de la lluvia.\n", "\n", "Lo haremos con los datos de lluvia normalizados a $[0,1]$.\n", "\n", "Supongamos que la verdadera función de regresión (rendimiento medio) es $f:[0,1]\\to\\mathbb{R}$ dada por:\n", "\n", "$$f(x) = -40.425 x^2 + 58.450 x +9.175$$\n", "\n", "Por lo tanto el rendimiento individual viene dado por el modelo\n", "\n", "$$y = f(x) + \\epsilon$$\n", "\n", "donde $\\epsilon$ indica ruido que suponemos normalmente distribuido, con media = 0 y varianza = 2.\n", "\n", "Vamos a suponer que $x$ está distribuida uniformemente en $[0,1]$.\n", "\n", "Estos supuestos son desconocidos en la práctica real, pero nos serviran para evaluar las técnicas de selección de modelos." ] }, { "cell_type": "code", "execution_count": null, "id": "1674e3ba-0502-4d06-8137-b942aaebe2ee", "metadata": { "id": "1674e3ba-0502-4d06-8137-b942aaebe2ee" }, "outputs": [], "source": [ "# Función verdadera\n", "A = -40.425\n", "B = 58.45\n", "C = 9.175\n", "\n", "def f(x):\n", " return A*(x**2) + B*x + C" ] }, { "cell_type": "code", "execution_count": null, "id": "fdcc0c10-5448-4dc8-a249-73c97a3c8523", "metadata": { "id": "fdcc0c10-5448-4dc8-a249-73c97a3c8523" }, "outputs": [], "source": [ "# Error irreducible\n", "sigma_epsilon = np.sqrt(2)" ] }, { "cell_type": "markdown", "id": "29c1a4c1-62ce-4fd1-b835-049d452f846d", "metadata": { "id": "29c1a4c1-62ce-4fd1-b835-049d452f846d" }, "source": [ "### Datos originales" ] }, { "cell_type": "markdown", "id": "d49407b4-34a5-4ebf-bc4e-f15c5b84a489", "metadata": { "id": "d49407b4-34a5-4ebf-bc4e-f15c5b84a489" }, "source": [ "Suponemos también que tenemos los siguientes datos:" ] }, { "cell_type": "code", "source": [ "#Si se usa Google Colab descomentar las siguientes líneas y elegir los archivos Papas.csv y Test.csv\n", "from google.colab import files\n", "uploaded = files.upload()" ], "metadata": { "id": "_nYHOnidT-JP" }, "id": "_nYHOnidT-JP", "execution_count": null, "outputs": [] }, { "cell_type": "code", "execution_count": null, "id": "b848f5e3-cab2-4187-9216-b5026b4d1db1", "metadata": { "id": "b848f5e3-cab2-4187-9216-b5026b4d1db1" }, "outputs": [], "source": [ "# Nuestro dataset de base S\n", "papas = pd.read_csv('/content/Papas.csv')\n", "papas" ] }, { "cell_type": "code", "execution_count": null, "id": "5e3dfbd3-0a5d-4c5e-9edf-04c3b392eb26", "metadata": { "id": "5e3dfbd3-0a5d-4c5e-9edf-04c3b392eb26" }, "outputs": [], "source": [ "# Cambiamos las unidades de Lluvia para disminuir errores numéricos\n", "papas['Lluvia'] = (papas['Lluvia']-50)/350" ] }, { "cell_type": "code", "execution_count": null, "id": "c0d62345-46e6-416e-be5c-7363b36976f9", "metadata": { "id": "c0d62345-46e6-416e-be5c-7363b36976f9" }, "outputs": [], "source": [ "plt.figure(figsize=(8, 4))\n", "x_range = np.linspace(0, 1, 1000)\n", "plt.plot(x_range, f(x_range), 'r', linewidth=3.0)\n", "\n", "plt.scatter(x = 'Lluvia',\n", " y = 'Rendimiento',\n", " data=papas\n", " )\n", "plt.xlabel('Lluvia')\n", "plt.ylabel('Rendimiento')\n", "plt.title(r'Dataset $S$ y función verdadera $f(x)$')\n", "plt.legend([r'$f(x)$', r'$S$'])\n", "plt.grid(True)\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "id": "fabeff1d-4bd9-4615-9650-71f3e38e2483", "metadata": { "id": "fabeff1d-4bd9-4615-9650-71f3e38e2483" }, "outputs": [], "source": [ "# Pasamos a numpy para trabajar con sklearn\n", "X = np.array(papas['Lluvia']).reshape(-1, 1)\n", "y = np.array(papas['Rendimiento']).reshape(-1, 1)" ] }, { "cell_type": "markdown", "id": "bfbe79a8-9664-4b78-bd40-3ce25202ecf4", "metadata": { "id": "bfbe79a8-9664-4b78-bd40-3ce25202ecf4" }, "source": [ "### Datos de test" ] }, { "cell_type": "markdown", "id": "4128bd13-6ea2-46f3-bf85-2697f18d1a7a", "metadata": { "id": "4128bd13-6ea2-46f3-bf85-2697f18d1a7a" }, "source": [ "Suponemos también que disponemos de los siguientes datos de test:" ] }, { "cell_type": "code", "execution_count": null, "id": "042b85c4-89bc-4a0a-b0d6-eb09ba40e753", "metadata": { "id": "042b85c4-89bc-4a0a-b0d6-eb09ba40e753" }, "outputs": [], "source": [ "# Nuestro dataset de test Stest\n", "test = pd.read_csv('Test.csv')\n", "test" ] }, { "cell_type": "code", "execution_count": null, "id": "4c75a800-80b8-4f67-8091-f31a6b1d6dab", "metadata": { "id": "4c75a800-80b8-4f67-8091-f31a6b1d6dab" }, "outputs": [], "source": [ "# Cambiamos las unidades de Lluvia para disminuir errores numéricos\n", "test['Lluvia'] = (test['Lluvia']-50)/350\n", "test" ] }, { "cell_type": "code", "execution_count": null, "id": "b1e6e083-6ced-4d65-b525-0451b18eeced", "metadata": { "id": "b1e6e083-6ced-4d65-b525-0451b18eeced" }, "outputs": [], "source": [ "plt.figure(figsize=(8, 4))\n", "x_range = np.linspace(0, 1, 1000)\n", "plt.plot(x_range, f(x_range), 'r', linewidth=3.0)\n", "\n", "plt.scatter(x = 'Lluvia',\n", " y = 'Rendimiento',\n", " data=papas\n", " )\n", "plt.scatter(x = 'Lluvia',\n", " y = 'Rendimiento',\n", " data=test\n", " )\n", "plt.xlabel('Lluvia')\n", "plt.ylabel('Rendimiento')\n", "plt.title(r'Datasets $S$, $S_{test}$ y función verdadera $f(x)$')\n", "plt.legend([r'$f(x)$', r'$S$',r'$S_{test}$'])\n", "plt.grid(True)\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "id": "f20c330c-9e39-4895-82e7-1f5be2da875c", "metadata": { "id": "f20c330c-9e39-4895-82e7-1f5be2da875c" }, "outputs": [], "source": [ "# Pasamos a numpy para trabajar con sklearn\n", "X_test = np.array(test['Lluvia']).reshape(-1, 1)\n", "y_test = np.array(test['Rendimiento']).reshape(-1, 1)" ] }, { "cell_type": "markdown", "id": "fc32581c-ac76-499e-abc4-446bc29f86c4", "metadata": { "id": "fc32581c-ac76-499e-abc4-446bc29f86c4" }, "source": [ "### Regresión lineal simple" ] }, { "cell_type": "markdown", "id": "4a7742b8-3234-4b31-89f7-d480409b39c7", "metadata": { "id": "4a7742b8-3234-4b31-89f7-d480409b39c7" }, "source": [ "#### Entrenamiento" ] }, { "cell_type": "code", "execution_count": null, "id": "6a1306da-956d-4f81-bccb-8ae86d38eaa8", "metadata": { "id": "6a1306da-956d-4f81-bccb-8ae86d38eaa8" }, "outputs": [], "source": [ "lin_reg = LinearRegression()\n", "lin_reg.fit(X, y)" ] }, { "cell_type": "code", "execution_count": null, "id": "28cdc861-e0fe-41c4-b29e-829fbac4ae4d", "metadata": { "id": "28cdc861-e0fe-41c4-b29e-829fbac4ae4d" }, "outputs": [], "source": [ "y_hat_S = lin_reg.predict(X)" ] }, { "cell_type": "code", "execution_count": null, "id": "297bd225-98ab-42cd-9695-c857d1f49bee", "metadata": { "id": "297bd225-98ab-42cd-9695-c857d1f49bee" }, "outputs": [], "source": [ "#RMSE\n", "RootMSE_S = np.sqrt(mean_squared_error(y,y_hat_S))\n", "RootMSE_S" ] }, { "cell_type": "markdown", "id": "bc23e316-ee17-4d8f-a72d-662d53875ef6", "metadata": { "id": "bc23e316-ee17-4d8f-a72d-662d53875ef6" }, "source": [ "#### Gráfico del modelo obtenido" ] }, { "cell_type": "code", "execution_count": null, "id": "12b3ed56-a5cc-4f53-ae4a-5b517f8536dc", "metadata": { "id": "12b3ed56-a5cc-4f53-ae4a-5b517f8536dc" }, "outputs": [], "source": [ "plt.figure(figsize=(8, 4))\n", "\n", "x_range = np.linspace(0, 1, 1000)\n", "X_range = x_range.reshape(-1, 1)\n", "y_hat_S = lin_reg.predict(X_range)\n", "\n", "plt.plot(x_range, f(x_range), 'r', linewidth=3.0)\n", "plt.plot(X_range, y_hat_S, 'tab:blue' , linewidth=3.0)\n", "\n", "plt.scatter(x = 'Lluvia',\n", " y = 'Rendimiento',\n", " data=papas\n", " )\n", "plt.scatter(x = 'Lluvia',\n", " y = 'Rendimiento',\n", " data=test\n", " )\n", "plt.xlabel('Lluvia')\n", "plt.ylabel('Rendimiento')\n", "plt.title(r'Datasets $S$, $S_{test}$, verdadera $f(x)$ y modelo $\\widehat{y}_S=f_{S}(x)$')\n", "plt.legend([r'$f(x)$', r'$f_S(x)$', r'$S$',r'$S_{test}$'])\n", "plt.grid(True)\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "053b310b-37cf-4fe7-bc80-5314cbcd8adb", "metadata": { "id": "053b310b-37cf-4fe7-bc80-5314cbcd8adb" }, "source": [ "#### MSE verdadera" ] }, { "cell_type": "markdown", "id": "30b97533-41d7-4bdd-b11d-bdc87df9cb50", "metadata": { "id": "30b97533-41d7-4bdd-b11d-bdc87df9cb50" }, "source": [ "Como conocemos la distribución $D$ de los datos podemos calcular el error verdadero\n", "\n", "$$\\text{MSE}(f_S)=\\mathbb{E}_{(x,y)\\sim D}\\Big[(y-f_S(x))^2\\Big]$$\n", "\n", "Esto es imposible en la práctica real." ] }, { "cell_type": "code", "execution_count": null, "id": "20b36665-858a-41a3-8a9e-198bf61b64ca", "metadata": { "id": "20b36665-858a-41a3-8a9e-198bf61b64ca" }, "outputs": [], "source": [ "# Coeficientes de f_S\n", "w0 = lin_reg.intercept_[0]\n", "w1 = lin_reg.coef_[0][0]\n", "print(w0,w1)" ] }, { "cell_type": "markdown", "id": "02611408-1ed9-474c-9ad8-c9c9981e58d8", "metadata": { "id": "02611408-1ed9-474c-9ad8-c9c9981e58d8" }, "source": [ "Denotamos $f(x)=Ax^2+Bx + C$ la función de regresión verdadera.\n", "\n", "El error verdadero del modelo $f_S(x)=w_0+w_1 x$ es\n", "\n", "$$\n", "\\begin{aligned}\n", "\\text{MSE}(f_S)\n", "& = \\mathbb{E}_{(x,y)\\sim D}\\Big[(y-f_S(x))^2\\Big]\\\\\n", "& = \\mathbb{E}_{(x,\\epsilon)}\\Big[(f(x)+\\epsilon-f_S(x))^2\\Big]\\\\\n", "& = \\mathbb{E}_{(x,\\epsilon)}\\Big[(Ax^2 + Bx + C +\\epsilon-w_0-w_1 x)^2\\Big]\\\\\n", "\\end{aligned}\n", "$$\n", "\n", "Juntando los coeficientes en las potencias de $x$ y desarrollando el cuadrado llegamos a la expresión\n", "\n", "$$\n", "\\begin{aligned}\n", "\\text{MSE}(f_S)\n", "& =\n", "\\sigma^2+A^2\\mathbb{E}[x^4]\\\\\n", "& + 2 A (B-w_1) \\mathbb{E}[x^3]\\\\\n", "& + ((B-w_1)^2+2 A (C-w_0))\\mathbb{E}[x^2]\\\\\n", "& + 2 (B-w_1)(C-w_0)\\mathbb{E}[x]\\\\\n", "& + (C-w_0)^2\n", "\\end{aligned}\n", "$$\n", "\n", "en donde aparecen los momentos de la distribución uniforme en $[0,1]$." ] }, { "cell_type": "markdown", "id": "cca76d4d", "metadata": { "id": "cca76d4d" }, "source": [ "Los momentos de la distribución uniforme en $[a,b]$ están dados por:\n", "\n", "$$\\mathbb{E}[x^n]=\\frac{b^{n+1}-a^{n+1}}{(n+1)(b-a)}$$\n", "\n", "por lo que para la uniforme en $[0,1]$ tenemos $\\mathbb{E}[x^n]=1/(n+1)$." ] }, { "cell_type": "code", "execution_count": null, "id": "0e55db84", "metadata": { "id": "0e55db84" }, "outputs": [], "source": [ "# Momentos de la uniforme\n", "exp_x = 1/2\n", "exp_x2 = 1/3\n", "exp_x3 = 1/4\n", "exp_x4 = 1/5" ] }, { "cell_type": "code", "execution_count": null, "id": "343f89b4-5534-4787-acce-7dd4a4e43819", "metadata": { "id": "343f89b4-5534-4787-acce-7dd4a4e43819" }, "outputs": [], "source": [ "e0 = (C-w0)**2\n", "e1 = 2*(B-w1)*(C-w0)*exp_x\n", "e2 = ((B-w1)**2+2*A*(C-w0))*exp_x2\n", "e3 = 2*A*(B-w1)*exp_x3\n", "e4 = (A**2)*exp_x4\n", "\n", "MSE = sigma_epsilon**2 + e0 + e1 + e2 + e3 + e4" ] }, { "cell_type": "code", "execution_count": null, "id": "5d05f760-3182-4e1c-bda9-70647d30295e", "metadata": { "id": "5d05f760-3182-4e1c-bda9-70647d30295e" }, "outputs": [], "source": [ "RootMSE = np.sqrt(MSE)\n", "RootMSE" ] }, { "cell_type": "markdown", "id": "2d210ba1-6f93-4ee7-83bd-3af7b9efc5b1", "metadata": { "id": "2d210ba1-6f93-4ee7-83bd-3af7b9efc5b1" }, "source": [ "#### Error en test" ] }, { "cell_type": "markdown", "id": "c8332624-dc97-4646-8d00-2a2dad62bd78", "metadata": { "id": "c8332624-dc97-4646-8d00-2a2dad62bd78" }, "source": [ "Como en la práctica no conocemos la distribución $D$, estimamos el error verdadero\n", "\n", "$$\\text{MSE}_{S_{test}}(f_S)=\\frac{1}{|S_{test}|}\\sum_{(x,y)\\in S_{test}}(y-f_S(x))^2$$\n", "\n", "Aquí $S_{test}$ es una muestra de $D$ independiente de $S$." ] }, { "cell_type": "code", "execution_count": null, "id": "afab162a-3355-4571-82ec-2e955d1720ad", "metadata": { "id": "afab162a-3355-4571-82ec-2e955d1720ad" }, "outputs": [], "source": [ "# Predicción en test\n", "y_hat_Stest = lin_reg.predict(X_test)" ] }, { "cell_type": "code", "execution_count": null, "id": "6456338c-be99-40e3-bf46-22b733b588de", "metadata": { "id": "6456338c-be99-40e3-bf46-22b733b588de" }, "outputs": [], "source": [ "# Error en test\n", "RootMSE_Stest = np.sqrt(mean_squared_error(y_test,y_hat_Stest))\n", "RootMSE_Stest" ] }, { "cell_type": "markdown", "id": "8fd20aed-9a61-4771-85f4-384b6e8b7a8a", "metadata": { "id": "8fd20aed-9a61-4771-85f4-384b6e8b7a8a" }, "source": [ "### Regresión lineal con polinomios" ] }, { "cell_type": "markdown", "id": "ec34163d-7f82-4476-8b71-12fc050ca4bc", "metadata": { "id": "ec34163d-7f82-4476-8b71-12fc050ca4bc" }, "source": [ "#### Entrenamiento" ] }, { "cell_type": "code", "execution_count": null, "id": "a4cd6e4d-f017-4fa2-97f1-1b8a4c834682", "metadata": { "id": "a4cd6e4d-f017-4fa2-97f1-1b8a4c834682" }, "outputs": [], "source": [ "# Entrenamos regresiones polinomiales para varios grados\n", "# Guardamos la info necesaria para predecir en test posteriormente\n", "modelos = []\n", "scalers = []\n", "polys = []\n", "M = []\n", "STD = []\n", "norm_intercepts = []\n", "norm_coefs = []\n", "\n", "# Grado máximo de los polinomios\n", "grado_max = 6\n", "\n", "for grado in range(1,grado_max+1):\n", " poly = PolynomialFeatures(degree=grado, include_bias=False)\n", " poly.fit(X)\n", " polys.append(poly)\n", " X_poly = poly.transform(X)\n", " m = np.mean(X_poly,axis=0)\n", " std= np.std(X_poly, axis=0)\n", "\n", " M.append(m)\n", " STD.append(std)\n", "\n", " scaler = StandardScaler()\n", " X_norm = scaler.fit_transform(X_poly)\n", " scalers.append(scaler)\n", "\n", " poly_reg = LinearRegression()\n", " poly_reg.fit(X_norm, y)\n", " modelos.append(poly_reg)\n", "\n", " norm_intercepts.append(poly_reg.intercept_[0])\n", " norm_coefs.append(poly_reg.coef_[0])" ] }, { "cell_type": "code", "execution_count": null, "id": "78dda6b3-29ab-452a-a37c-c839f91984b7", "metadata": { "id": "78dda6b3-29ab-452a-a37c-c839f91984b7" }, "outputs": [], "source": [ "# Desnormalizamos los coeficientes\n", "intercepts = []\n", "coefs = []\n", "\n", "for k in range(len(norm_coefs)):\n", " beta0 = norm_intercepts[k]\n", " beta = norm_coefs[k]\n", " m = M[k]\n", " std = STD[k]\n", " intercepts.append(beta0 - np.sum(m*beta/std))\n", " coefs.append(beta/std)" ] }, { "cell_type": "markdown", "id": "049640f0-4c73-4e37-a5ee-d20a0f3898c8", "metadata": { "id": "049640f0-4c73-4e37-a5ee-d20a0f3898c8" }, "source": [ "#### Error en train, en test y verdadero" ] }, { "cell_type": "code", "execution_count": null, "id": "6469c2c5-3de4-41d6-a56f-57077b6e1c50", "metadata": { "id": "6469c2c5-3de4-41d6-a56f-57077b6e1c50" }, "outputs": [], "source": [ "# Calculamos los MSE en train, test y verdadero con el objetivo de graficarlos\n", "MSEs = []\n", "MSEs_S = []\n", "MSEs_Stest = []\n", "momentos = [1/(n+1) for n in range(2*max(grado_max,2)+1)]\n", "\n", "for k in range(len(modelos)):\n", " # Coeficientes\n", " w0 = np.array([intercepts[k]])\n", " w1 = coefs[k]\n", " w = np.concatenate((w0,w1))\n", " if len(w) == 2:\n", " polinomio = np.concatenate((w,np.zeros(1)))-np.array([C,B,A])\n", " elif len(w) == 3:\n", " polinomio = w-np.array([C,B,A])\n", " else:\n", " polinomio = w-np.concatenate((np.array([C,B,A]),np.zeros(len(w)-3)))\n", "\n", " # MSE verdadero\n", " terminos = []\n", " for i in range(len(polinomio)):\n", " for j in range(len(polinomio)):\n", " terminos.append(polinomio[i]*polinomio[j]*momentos[i+j])\n", " MSEs.append(sigma_epsilon**2+sum(terminos))\n", "\n", " # Modelo y transformaciones\n", " f_S = modelos[k]\n", " poly = polys[k]\n", " scaler = scalers[k]\n", "\n", " # MSE en train\n", " X_poly = poly.transform(X)\n", " X_norm = scaler.transform(X_poly)\n", " y_hat_S = f_S.predict(X_norm)\n", " MSEs_S.append(mean_squared_error(y,y_hat_S))\n", "\n", " # MSE en test\n", " X_test_poly = poly.transform(X_test)\n", " X_test_norm = scaler.transform(X_test_poly)\n", " y_hat_Stest = f_S.predict(X_test_norm)\n", " MSEs_Stest.append(mean_squared_error(y_test,y_hat_Stest))" ] }, { "cell_type": "code", "execution_count": null, "id": "693b4d1b-4b99-4665-b2c7-76f52c6e31a2", "metadata": { "id": "693b4d1b-4b99-4665-b2c7-76f52c6e31a2", "outputId": "f81eb896-1db3-4eb5-85b5-9d99f1eddf47", "colab": { "base_uri": "https://localhost:8080/", "height": 413 } }, "outputs": [ { "output_type": "display_data", "data": { "text/plain": [ "
" ], "image/png": "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\n" }, "metadata": {} } ], "source": [ "plt.figure(figsize=(8, 4))\n", "plt.plot(range(1,grado_max+1),np.sqrt(MSEs), '-o')\n", "plt.plot(range(1,grado_max+1),np.sqrt(MSEs_S), '-o')\n", "plt.plot(range(1,grado_max+1),np.sqrt(MSEs_Stest), '-o')\n", "plt.xlabel('Grado')\n", "plt.ylabel('Error')\n", "plt.title(r'Errores de $\\widehat{y}_S=f_{S}(x)$ en función del grado')\n", "plt.legend([r'Verdadero: Root $MSE(f_S)$',r'Train: Root $MSE_S(f_S)$',r'Test: Root $MSE_{S_{test}}(f_S)$'])\n", "plt.grid(True)\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "b19ed99d", "metadata": { "id": "b19ed99d" }, "source": [ "Notar que $MSE$ es bien aproximada por $MSE_{S_{test}}$." ] }, { "cell_type": "markdown", "id": "8a826054-7639-4050-b7aa-95ed9b326350", "metadata": { "id": "8a826054-7639-4050-b7aa-95ed9b326350" }, "source": [ "## Visualización del sesgo y la varianza" ] }, { "cell_type": "code", "execution_count": null, "id": "1a227d91-3619-478d-aa09-ab8108119f64", "metadata": { "id": "1a227d91-3619-478d-aa09-ab8108119f64" }, "outputs": [], "source": [ "# Definimos nuestro modelo polinomial usando Numpy porque es más rápido\n", "def h(x, w):\n", " d = len(w) - 1\n", " return np.sum(w * np.power(x, np.expand_dims(np.arange(d, -1, -1), 1)).T, 1)" ] }, { "cell_type": "code", "execution_count": null, "id": "3a342bef-52f5-4aff-9f0e-3411a429f83c", "metadata": { "id": "3a342bef-52f5-4aff-9f0e-3411a429f83c" }, "outputs": [], "source": [ "# Vamos a generar varias hipótesis polinomiales con una fracción de los datos\n", "n = 15\n", "\n", "# Definimos el rango de valores de x\n", "x_range = np.linspace(0, 1, 1000)\n", "\n", "# Definimos los grados de los polinomios\n", "d_arr = range(1,6)\n", "\n", "# Cantidad R de datasets\n", "R = 10000" ] }, { "cell_type": "code", "execution_count": null, "id": "2b1f6b4c-3d17-41da-b0aa-fbe3acde08d9", "metadata": { "id": "2b1f6b4c-3d17-41da-b0aa-fbe3acde08d9" }, "outputs": [], "source": [ "# Graficamos\n", "fig, axs = plt.subplots(2, 1, sharex=True, sharey=True, figsize=(8,8))\n", "\n", "for k in range(2):\n", " # Iteramos en los R datasets\n", " models = np.zeros((R,len(x_range)))\n", " for r in range(R):\n", " # Vector de valores de x\n", " x_train = np.random.rand(n)\n", "\n", " # Ruido\n", " epsilon = sigma_epsilon * np.random.randn(n)\n", "\n", " # Función verdadera + ruido\n", " y_train = f(x_train) + epsilon\n", "\n", " d = d_arr[k]\n", " w = np.polyfit(x_train, y_train, d)\n", " models[r,:] = h(x_range,w)\n", "\n", " # Graficamos la función de regresión verdadera\n", " axs[k].plot(x_range, f(x_range), 'r', linewidth=3.0)\n", " axs[k].plot(x_range, np.mean(models,axis=0), 'g', linewidth=3.0)\n", " axs[k].fill_between(\n", " x_range,\n", " np.mean(models,axis=0) - np.std(models,axis=0),\n", " np.mean(models,axis=0) + np.std(models,axis=0),\n", " alpha=0.2,\n", " color=\"tab:green\",\n", " lw=2,\n", " )\n", " axs[k].legend([r'$f(x)$',r'$\\mathbb{E}_S(f_S(x))$',r'$Var_{S}(f_S(x))$'])\n", "\n", " axs[k].grid(True)\n", " axs[k].title.set_text('d = {}'.format(d_arr[k]))\n", "\n", "plt.xlabel('Lluvia')\n", "plt.ylabel('Rendimiento')\n", "plt.suptitle(r'Sesgo y Varianza')\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "id": "c6ef67b9", "metadata": { "id": "c6ef67b9" }, "outputs": [], "source": [ "# Graficamos\n", "fig, axs = plt.subplots(2, 1, sharex=True, sharey=True, figsize=(8,8))\n", "\n", "for k in range(2):\n", " # Iteramos en los R datasets\n", " models = np.zeros((R,len(x_range)))\n", " for r in range(R):\n", " # Vector de valores de x\n", " x_train = np.random.rand(n)\n", "\n", " # Ruido\n", " epsilon = sigma_epsilon * np.random.randn(n)\n", "\n", " # Función verdadera + ruido\n", " y_train = f(x_train) + epsilon\n", "\n", " d = d_arr[k+2]\n", " w = np.polyfit(x_train, y_train, d)\n", " models[r,:] = h(x_range,w)\n", "\n", " # Graficamos la función de regresión verdadera\n", " axs[k].plot(x_range, f(x_range), 'r', linewidth=3.0)\n", " axs[k].plot(x_range, np.mean(models,axis=0), 'g', linewidth=3.0)\n", " axs[k].fill_between(\n", " x_range,\n", " np.mean(models,axis=0) - np.std(models,axis=0),\n", " np.mean(models,axis=0) + np.std(models,axis=0),\n", " alpha=0.2,\n", " color=\"tab:green\",\n", " lw=2,\n", " )\n", " axs[k].legend([r'$f(x)$',r'$\\mathbb{E}_S(f_S(x))$',r'$Var_{S}(f_S(x))$'])\n", "\n", " axs[k].grid(True)\n", " axs[k].title.set_text('d = {}'.format(d_arr[k+2]))\n", "\n", "plt.xlabel('Lluvia')\n", "plt.ylabel('Rendimiento')\n", "plt.suptitle(r'Sesgo y Varianza')\n", "plt.tight_layout()\n", "plt.show()" ] } ], "metadata": { "colab": { "provenance": [], "toc_visible": true }, "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.8.15" } }, "nbformat": 4, "nbformat_minor": 5 }