{ "cells": [ { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "qwRIzDC9TbD2" }, "source": [ "# Laboratorio 4 - Parte 2" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "cww0rGZXTbDv" }, "source": [ "\n", " \"Open\n", "\n", "**Recuerda que una vez abierto, Da clic en \"Copiar en Drive\", de lo contrario no podras almacenar tu progreso**\n", "\n", "Nota: no olvide ir ejecutando las celdas de código de arriba hacia abajo para que no tenga errores de importación de librerías o por falta de definición de variables." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "vB07QCZfTbDx" }, "outputs": [], "source": [ "#configuración del laboratorio\n", "# Ejecuta esta celda!\n", "%load_ext autoreload\n", "%autoreload 2\n", "#for local \n", "#import sys ; sys.path.append('../commons/utils/')\n", "!wget https://raw.githubusercontent.com/jdariasl/ML_2020/master/Labs/commons/utils/general.py -O general.py --no-cache\n", "from general import configure_lab4\n", "configure_lab4()\n", "from lab4 import *\n", "GRADER = part_2()" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "lkLns0kiTbD3" }, "source": [ "En este laboratorio vamos analizar el efecto del sobre-ajuste (*over-fitting*), como identificarlo y como podemos regualizar los modelos para evitarlo o disminuir su efecto. \n", "\n", "En este laboratorio, vamos a enfocarnos en 2 modelos (usando libreria de sklearn): \n", "\n", "1. Regresión logistica \n", "2. MLP\n", "\n", "**No vamos enfocarnos en como tratar la maldición de la dimensionalidad** ya que esto lo vamos a ver un poco más adelante cuando evaluemos las tecnicas de selección de caracteristicas." ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "cBGpm893TbD3" }, "source": [ "Vamos usar [el dataset de digitos escritos a mano](https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_digits.html) para realizar nuestra practica." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "aE2yg_cETbD3" }, "outputs": [], "source": [ "x,y = load_digits(return_X_y=True)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "VYnk2FwSTbD5" }, "source": [ "Una de las condiciones para que se presente sobre-ajustes es tener un conjunto de entrenamiento pequeño. \n", "\n", "En nuestra practica vamos a simular esta condición para ver que tecnicas podemos usar para reducir el efecto del sobre-ajuste. \n", "\n", "**Nota**\n", "1. En un problema real, si se observa que las medidas de rendimiento no llegan satisfacen las necesidades, la respuesta puede ser que se necesitan más datos en el conjunto de entrenamiento.\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "9OQdVTAZTbD5" }, "outputs": [], "source": [ "# simular conjunto de datos pequeño\n", "x, x_test, y, y_test = train_test_split(\n", " x, y, test_size=0.6, random_state=10)\n", "scaler = StandardScaler().fit(x)\n", "x = scaler.transform(x)\n", "x_test = scaler.transform(x_test)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "Ap6L4HQwTbD7" }, "source": [ "## Ejercicio 1 - Detectar sobre ajuste" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "vGta0nulTbD7" }, "source": [ "En nuestro primer ejercicio vamos a entrenar un MLP con una arquitectura especifica, pero:\n", "1. usaremos cross validación.\n", "2. calcular error de entrenamiento y prueba\n", "3. la función recibe de manera arbitraria un estimador de sklearn\n", "4. [usar accuracy score como medida de rendimiento](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html#sklearn.metrics.accuracy_score)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "mggj15DfTbD8" }, "outputs": [], "source": [ "# ejercicio de código\n", "def diff_train_test(sklearnModel, Xtrain, Ytrain, Xtest, Ytest):\n", " \"\"\"función que retorna error de entrenamiento\n", " sklearnModel: objeto estimador de sklearn ya entrenado\n", " X: matriz numpy con las caracteristicas\n", " Y: vector de numpy con las etiquetas\n", " \n", " retorna: tuple con tres elementos:\n", " error entrenamiento, error test y \n", " diff entre error y test\n", " \"\"\"\n", " error_train = accuracy_score(y_true = , y_pred = sklearnModel.predict( ) )\n", " error_test = accuracy_score(y_true= , y_pred = sklearnModel.predict( ))\n", " diff = error_test - error_train\n", " return (error_train, error_test, diff)\n", " " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "OM6tpVKHTbD9" }, "outputs": [], "source": [ "## la funcion que prueba tu implementacion\n", "GRADER.run_test(\"ejercicio1\", diff_train_test)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "NUhxHnmzTbD_" }, "source": [ "Con la función construida, vamos a usarla para verificar la differencia entre el error de entrenamiento y prueba para los dos modelos que vamos a usar:\n", "1. MLP con dos capas, cada una con 64 neuornas. `random_state=1` es usado para lograr tener los mismos resultados siempre\n", "2. [Regresión logistica forzada para que no use ninguna regularización](https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html#sklearn.linear_model.LogisticRegression). `random_state=1` es usado para lograr tener los mismos resultados" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "o9gaJVOxTbEA" }, "outputs": [], "source": [ "mlp = MLPClassifier(hidden_layer_sizes=[20,20], max_iter=500, alpha =1e-6, random_state=1)\n", "mlp.fit(x, y)\n", "# aca usamos el * para pasa cada elemento como argumento \n", "print(\"MLP entrenamiento:{0:.3f}, test:{1:.3f} y diff {2:.3f}\".format(*diff_train_test(mlp,x,y, x_test, y_test)))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "6qkKdVakTbEC" }, "outputs": [], "source": [ "reg = LogisticRegression(penalty='none', max_iter=500, random_state=1)\n", "reg.fit(x, y)\n", "print(\"Logistic Regresion entrenamiento:{0:.3f}, test:{1:.3f} y diff {2:.3f}\".format(*diff_train_test(reg,x,y, x_test, y_test)))" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "I6t9dJ5ETbEE" }, "source": [ "## Ejercicio 2 - Experimentar con MLP regularizado" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "cZpv_cP-TbEE" }, "source": [ "Vamos a comenzar regularizar el modelo, el primer metodo que vamos a usar es el de parada anticipada (*early-stopping*). Este ya se encuentra implementado dentro de la libreria, vamos a experimentar con este parametro y el el numero de neuronas en el MLP." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "cellView": "form", "colab": {}, "colab_type": "code", "id": "SkoSdxHfTbEE" }, "outputs": [], "source": [ "#@title Pregunta Abierta\n", "#@markdown ¿Explique en sus palabras a que corresponde el metodo de parada anticipada?\n", "respuesta_1 = \"\" #@param {type:\"string\"}" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "cellView": "form", "colab": {}, "colab_type": "code", "id": "77yPBEmjTbEG" }, "outputs": [], "source": [ "#@title Pregunta Abierta\n", "#@markdown ¿basandose en la documentación de sklearn para MLPClassifier que relación tiene el parametro validation_fraction con la parada anticipada?\n", "respuesta_2 = \"\" #@param {type:\"string\"}" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "bBQr3xG_TbEI" }, "outputs": [], "source": [ "# ejercicio de código\n", "def exp_mlp_early_stop(Xtrain,Xtest,Ytrain, Ytest, num_neurons, is_early_stop):\n", " \"\"\" función para realizar experimentos con el MLP con early stopping\n", " Xtrain: matriz de numpy con caracteristicas de entrenamiento\n", " Xtest: matriz de numpy con caracteristicas de prueba\n", " ytrain: vector numpy con etiqueta de entrenamiento\n", " ytest: vector numpy con etiqueta de prueba\n", " num_neurons: list de enteros con el numero de neuronas a usar\n", " is_early_stop: list de boolean para confirmar si se aplica early stop\n", " \n", " Retorna: dataframe con 5 columnas:\n", " - numero de neuronas\n", " - error de entrenamiento\n", " - error de prueba\n", " - diferencia entrenamiento y prueba \n", " \"\"\"\n", " resultados = pd.DataFrame()\n", " idx = 0\n", " for early_stop in is_early_stop:\n", " for neurons in num_neurons:\n", " #Haga el llamado a la función para crear y entrenar el modelo usando los datos de entrenamiento\n", " # prestar atención a los parametros, correctos.\n", " hidden_layer_sizes = tuple(2*[neurons])\n", " # llame el parametro que el MLP pare anticipadamente\n", " mlp = MLPClassifier(hidden_layer_sizes= hidden_layer_sizes, max_iter = 1000,random_state=1 ... )\n", " # entrenar\n", " mlp.fit(X=..., y=...)\n", " # llamar la funcion creada anteriomente\n", " error_train, error_test, diff = diff_train_test(mlp, Xtrain, Ytrain, Xtest, Ytest)\n", "\n", " resultados.loc[idx,'neuronas en capas ocultas'] = neurons \n", " resultados.loc[idx,'error de entrenamiento'] = ...\n", " resultados.loc[idx,'error de prueba'] = ...\n", " resultados.loc[idx,'diferencia entrenamiento y prueba'] = ...\n", " resultados.loc[idx,'is_early_stop'] = early_stop\n", " idx+=1\n", " return (resultados)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "OdbI_6iZTbEK" }, "outputs": [], "source": [ "## la funcion que prueba tu implementacion\n", "GRADER.run_test(\"ejercicio2\", exp_mlp_early_stop)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "OmEqW2qgTbEM" }, "outputs": [], "source": [ "res_early_stop = exp_mlp_early_stop(x, x_test, y, y_test, [8,16,20,24], [True, False])" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "ssdnLBHCTbEN" }, "outputs": [], "source": [ "import seaborn as sns\n", "sns.relplot(x = 'neuronas en capas ocultas', y='diferencia entrenamiento y prueba', hue = 'is_early_stop', data = res_early_stop, kind = 'line', aspect=2)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "IYhFhofwTbEP" }, "source": [ "Ahora vamos a experimentar con el parametro L2 del MLP." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "cellView": "form", "colab": {}, "colab_type": "code", "id": "5Rbf21WdTbEQ" }, "outputs": [], "source": [ "#@title Pregunta Abierta\n", "#@markdown ¿explique en sus palabras en qué consiste la regularización L2?\n", "respuesta_3 = \"\" #@param {type:\"string\"}" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "LS6Sz86HTbER" }, "outputs": [], "source": [ "# ejercicio de código\n", "def exp_mlp_l2(Xtrain,Xtest,Ytrain, Ytest, num_neurons, l2_values):\n", " \"\"\" función para realizar experimentos con el MLP con early stopping\n", " Xtrain: matriz de numpy con caracteristicas de entrenamiento\n", " Xtest: matriz de numpy con caracteristicas de prueba\n", " ytrain: vector numpy con etiqueta de entrenamiento\n", " ytest: vector numpy con etiqueta de prueba\n", " num_neurons: list de enteros con el numero de neuronas a usar\n", " l2: list de floats con valores para regularizacion l2\n", " \n", " Retorna: dataframe con 5 columnas:\n", " - numero de neuronas\n", " - error de entrenamiento\n", " - error de prueba\n", " - diferencia entrenamiento y prueba \n", " \"\"\"\n", " resultados = pd.DataFrame()\n", " idx = 0\n", " for l2 in l2_values:\n", " for neurons in num_neurons:\n", " #Haga el llamado a la función para crear y entrenar el modelo usando los datos de entrenamiento\n", " # prestar atención a los parametros, correctos.\n", " hidden_layer_sizes = tuple(2*[neurons])\n", " # llame el parametro adecuado del MLPClassifier\n", " mlp = MLPClassifier(hidden_layer_sizes= hidden_layer_sizes, max_iter = 1000, random_state=1, ...)\n", " mlp.fit(X=..., y=...)\n", " # llamar la funcion creada anteriomente\n", " error_train, error_test, diff = diff_train_test(mlp, Xtrain, Ytrain, Xtest, Ytest)\n", " resultados.loc[idx,'neuronas en capas ocultas'] = neurons \n", " resultados.loc[idx,'error de entrenamiento'] = ...\n", " resultados.loc[idx,'error de prueba'] = ...\n", " resultados.loc[idx,'diferencia entrenamiento y prueba'] = ...\n", " resultados.loc[idx,'l2'] = l2\n", " idx+=1\n", " return (resultados)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "B9WxvFIvTbEU" }, "outputs": [], "source": [ "## la funcion que prueba tu implementacion\n", "GRADER.run_test(\"ejercicio3\", exp_mlp_l2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "Ou3NnHTMTbEW" }, "outputs": [], "source": [ "res_l2 = exp_mlp_l2(x, x_test, y, y_test, [8,16,20,24], [1e-6,1e-3,1e-1,1e0, 1e1])" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "JbiYggBzTbEY" }, "outputs": [], "source": [ "sns.relplot(x = 'l2', y='diferencia entrenamiento y prueba',\n", " hue = 'neuronas en capas ocultas', \n", " data = res_l2, kind = 'line', \n", " aspect=2, palette=sns.color_palette('viridis', n_colors=res_l2['neuronas en capas ocultas'].nunique()))" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "cellView": "form", "colab": {}, "colab_type": "code", "id": "R9RW7MYKTbEZ" }, "outputs": [], "source": [ "#@title Pregunta Abierta\n", "#@markdown ¿qué efecto tiene el L2 en el overfitting/sobre-ajuste? explique\n", "respuesta_4 = \"\" #@param {type:\"string\"}" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "9-iNKrRoTbEb" }, "source": [ "## Ejercicio 3 - Experimentar con regresión logistica regularizada" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "CKRD9YADTbEb" }, "source": [ "Ahora vamos explorar la opciones de regularización de la regresión logistica. En la libreria se implementan más formas de regularizar, pero solo vamos a comprobar la regularización de norma L2." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "PDooOislTbEd" }, "outputs": [], "source": [ "# ejercicio de código\n", "def exp_reg_l2(Xtrain,Xtest,Ytrain, Ytest, l2_values):\n", " \"\"\" función para realizar experimentos con el MLP con early stopping\n", " Xtrain: matriz de numpy con caracteristicas de entrenamiento\n", " Xtest: matriz de numpy con caracteristicas de prueba\n", " ytrain: vector numpy con etiqueta de entrenamiento\n", " ytest: vector numpy con etiqueta de prueba\n", " l2: list de floats con valores para regularizacion l2\n", " \n", " Retorna: dataframe con 5 columnas:\n", " - numero de neuronas\n", " - error de entrenamiento\n", " - error de prueba\n", " - diferencia entrenamiento y prueba \n", " \"\"\"\n", " resultados = pd.DataFrame()\n", " idx = 0\n", " for l2 in l2_values:\n", " #Haga el llamado a la función para crear y entrenar el modelo usando los datos de entrenamiento\n", " # prestar atención a los parametros, correctos., para lograr\n", " # la regularizacion deseada (pasar el valor de \"l2\" directamente al parametro de la libreria asociado)\n", " reg = LogisticRegression(max_iter = 500, random_state=1, ...)\n", " reg.fit(X=..., y=...)\n", " # llamar la funcion creada anteriomente\n", " error_train, error_test, diff = diff_train_test(reg, Xtrain, Ytrain, Xtest, Ytest)\n", " resultados.loc[idx,'error de entrenamiento'] = ...\n", " resultados.loc[idx,'error de prueba'] = ...\n", " resultados.loc[idx,'diferencia entrenamiento y prueba'] = ...\n", " resultados.loc[idx,'l2'] = l2\n", " idx+=1\n", " return (resultados)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "c5OPNTlITbEe" }, "outputs": [], "source": [ "## la funcion que prueba tu implementacion\n", "GRADER.run_test(\"ejercicio4\", exp_reg_l2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "jWZIM72aTbEf" }, "outputs": [], "source": [ "reg_l2 = exp_reg_l2(x, x_test, y, y_test, [1e-6,1e-3,1e-1,1e0, 1e1])" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "iNQ3fOPeTbEh" }, "outputs": [], "source": [ "sns.relplot(x = 'l2', y='diferencia entrenamiento y prueba',\n", " data = reg_l2, kind = 'line', \n", " aspect=2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "cellView": "form", "colab": {}, "colab_type": "code", "id": "i4weYXfHTbEj" }, "outputs": [], "source": [ "#@title Pregunta Abierta\n", "#@markdown ¿qué efecto tiene el parametro que controla L2 en la regresión logistica en el overfitting? es diferente al MLP?\n", "respuesta_5 = \"\" #@param {type:\"string\"}" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "RIAM660hTbEk" }, "source": [ "## Ejercicio 4 Efecto del tamaño del conjunto de entrenamiento\n", "\n", "Finalmente como mencionamos anteriormente, en los ejercicios que hemos resuelto, estabamos simulando la situación de un conjunto de datos de entrenamiento pequeño. En nuestro ultimo ejercicio vamos comprobar el efecto del tamaño del conjunto de entrenamiento." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "3lh2LQUhTbEk" }, "outputs": [], "source": [ "# ejercicio de codigo\n", "def train_size_experiments(sk_estimator, train_pcts,X,Y):\n", " \"\"\"funcion que realiza experimentos para\n", " comprobar la influencia del tamaño de conjunto\n", " de entrenamiento.\n", " \n", " sk_estimator: estimador/modelo de sklearn definido (sin entrenar)\n", " train_pcts: lista de floats con los pct de entrenamiento a evaluar\n", " X: matriz de numpy del conjunto de caracteristicas\n", " Y: vector numpy con las etiquetas\n", " \n", " Retorna: dataframe con 5 columnas:\n", " - tamaño del conjunto de entrenamiento (porcentaje!)\n", " - error de entrenamiento\n", " - error de prueba\n", " - diferencia entrenamiento y prueba \n", " \"\"\"\n", " resultados = pd.DataFrame()\n", " idx = 0\n", " for train_pct in train_pcts:\n", " #complete el con train_pct\n", " # preste atencion a que parametro usar!\n", " # recuerde que son porcentajes\n", " Xtrain, Xtest, Ytrain, Ytest = train_test_split(X, Y, random_state=10, ...)\n", " # normalizamos\n", " scaler = StandardScaler().fit(Xtrain)\n", " Xtrain = scaler.transform(Xtrain)\n", " Xtest = scaler.transform(Xtest)\n", " # entrenar!\n", " sk_estimator.fit(X=..., y=...)\n", " # llamar la funcion creada anteriomente\n", " error_train, error_test, diff = diff_train_test(sk_estimator, Xtrain, Ytrain, Xtest, Ytest)\n", " resultados.loc[idx,'error de entrenamiento'] = ...\n", " resultados.loc[idx,'error de prueba'] = ...\n", " resultados.loc[idx,'diferencia entrenamiento y prueba'] = ...\n", " # complete con el tamaño del entrenamiento\n", " resultados.loc[idx,'tamaño de entrenamiento'] = ...\n", " idx+=1\n", " \n", " return (resultados)\n", " " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "I1VGs0OgTbEm" }, "outputs": [], "source": [ "## la funcion que prueba tu implementacion\n", "GRADER.run_test(\"ejercicio5\", train_size_experiments)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "1XOHyRcgTbEn" }, "outputs": [], "source": [ "# debemos recargar nuestro conjunto de datos\n", "x,y = load_digits(return_X_y=True)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "ccI07QKMTbEp" }, "outputs": [], "source": [ "# comprobamos con un MLP\n", "mlp = MLPClassifier(hidden_layer_sizes=[20,20], max_iter=500, random_state=1)\n", "train_size_exp = train_size_experiments(mlp, [0.2,0.3,0.5,0.7,0.9], x, y)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "qxeHuXtnTbEr" }, "outputs": [], "source": [ "# vemos las tres medidas\n", "ax = train_size_exp.plot(x=\"tamaño de entrenamiento\", y=\"error de entrenamiento\", color=\"b\", legend=False, figsize = (9,6))\n", "train_size_exp.plot(x=\"tamaño de entrenamiento\", y=\"error de prueba\", ax=ax, legend=False, color=\"r\")\n", "ax2 = ax.twinx()\n", "ax2.set_ylabel(\"diff train y test\")\n", "ax.set_ylabel(\"eficiencia\")\n", "train_size_exp.plot(x=\"tamaño de entrenamiento\", y=\"diferencia entrenamiento y prueba\", ax=ax2, legend=False, color=\"k\")\n", "ax.figure.legend(loc = 'best')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "Rh_0RiBXTbEs" }, "source": [ "**Notas Finales ** \n", "\n", "Para tener en cuenta: [Sklearn hay una libreria que realiza algo similar a lo que creamos en el anterior ejercicio.](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.learning_curve.html)" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "dz3iJ10pTbEs" }, "source": [ "Debemos notar que en esta practica exageramos algunas situaciones para lograr medir y ver el efecto del sobre-ajuste. En la practica un flujo de trabajo mas ideal es el siguiente:\n", "\n", "\"grid_search_workflow\"\n" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "Oz3w7bYJTbEt" }, "source": [ "1. dividimos el conjunto al inicio, reservando un conjunto de test. \n", "2. verificamos los mejores parametros mediante validación cruzada. \n", "3. reentrenamos con los mejores parametros y realizamos la evaluación final. \n", "4. En esta última etapa es donde validamos si existe sobre ajuste. Si existe, se deben incluir parametros para mitigar el sobre ajuste en la validación cruzada y volver al paso 2." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "BKIT-LYSTbEt" }, "outputs": [], "source": [ "GRADER.check_tests()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "cellView": "form", "colab": {}, "colab_type": "code", "id": "kJSs79rzTbEu" }, "outputs": [], "source": [ "#@title Integrantes\n", "codigo_integrante_1 ='' #@param {type:\"string\"}\n", "codigo_integrante_2 = '' #@param {type:\"string\"}" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "JBLsuTAtTbEw" }, "source": [ "----\n", "esta linea de codigo va fallar, es de uso exclusivo de los profesores\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "colab": {}, "colab_type": "code", "id": "KhZOwh83TbEw" }, "outputs": [], "source": [ "GRADER.grade()" ] } ], "metadata": { "colab": { "collapsed_sections": [], "name": "lab4_parte2.ipynb", "provenance": [] }, "kernelspec": { "display_name": "Python 3", "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.7.6" } }, "nbformat": 4, "nbformat_minor": 1 }