{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "1DGtR6cMt-DU"
},
"source": [
"# Laboratorio 1 - Parte 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"**Regresión polinomial múltiple**"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "zE8l20T-t-DR"
},
"source": [
"![\"Open](\"https://colab.research.google.com/assets/colab-badge.svg\")
\n",
"\n",
"**Recuerda que una vez abierto, Da clic en \"Copiar en Drive\", de lo contrario no podras alamancenar 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.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 289
},
"colab_type": "code",
"id": "19BFks1nt-DR",
"outputId": "f9f6a89f-19ec-42f8-9c80-ed5d70e890d5",
"tags": []
},
"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\n",
"from general import configure_lab1_p1\n",
"configure_lab1_p1()\n",
"from lab1 import *\n",
"GRADER_LAB_1_P1, db, x, y = part_1()"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "0MJDEwjht-DV"
},
"source": [
"### Ejercicio 1: Contextualización del problema\n",
"\n",
"El problema de regresión que abordaremos consiste en predecir el valor de la humedad absoluta en el aire, a partir de varias variables sensadas en el aire (Para más información sobre la base de datos y la contextualización del problema, consulte: http://archive.ics.uci.edu/ml/datasets/air+quality)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {
"base_uri": "https://localhost:8080/",
"height": 153
},
"colab_type": "code",
"id": "HeVKE-aot-DV",
"outputId": "be399113-4bd1-4f4a-c85b-cbfe2711894b",
"tags": []
},
"outputs": [],
"source": [
"# tienes ya cargadas las siguientes variables:\n",
"print(\"conjunto de datos\", x)\n",
"print(\"variable a predecir\", y)\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "-sSUDTQOt-DZ",
"tags": []
},
"outputs": [],
"source": [
"#Ejercicio de Codigo\n",
"def num_muestras_carac(X):\n",
" \"\"\"Esta funcion es encargada retornar el numero de muestras\n",
" y caracteristicas del conjunto de datos X\n",
"\n",
" X: matriz numpy\n",
" retorna:\n",
" numero de muestras (int/float)\n",
" numero de caracteristicas (int/float)\n",
" \"\"\"\n",
" \n",
" return (None)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "E3p3FE_Jt-Da",
"tags": []
},
"outputs": [],
"source": [
"## la funcion que prueba tu implementacion\n",
"GRADER_LAB_1_P1.run_test(\"ejercicio1\", num_muestras_carac)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"cellView": "form",
"colab": {},
"colab_type": "code",
"id": "WjDP5hKtt-Dc"
},
"outputs": [],
"source": [
"#@title Pregunta Abierta\n",
"#@markdown ¿que tipo de problema vamos a resolver? justifique su respuesta \n",
"respuesta_1 = \"\" #@param {type:\"string\"}"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "IsCCj-RFt-De"
},
"source": [
"### Ejercicio 2\n",
"\n",
"Analice los siguientes métodos de la teoría de modelos de *regresión polinomial múltiple*:\n",
"\n",
"1. error cuadrático medio (ECM), \n",
"2. modelo de regresión múltiple (regression)\n",
"3. potencia del polinomio (potenciaPolinomio)\n",
"4. gradiente descendente.\n",
"\n",
"Para los tres primeros métodos, su implementación en código es dentro del notebook. Por ejemplo la siguiente celda contiene la implementación del ECM y de la regression. Comprenda su funcionamiento y ejecute la celda para definir las funciones y poder usarlas.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "uautFfy5t-De"
},
"outputs": [],
"source": [
"def ECM(Y_est,Y):\n",
" \"\"\"funcion para calcular el error cuadratico medio\n",
" Y_est: debe contener los valores predichos por el modelo evaluar\n",
" Y: debe contener los valores reales\n",
" retorna: error cuadratico medio\n",
" \"\"\"\n",
" N = np.size(Y)\n",
" ecm = np.sum((Y_est.reshape(N,1) - Y.reshape(N,1))**2)/(N)\n",
" return ecm \n",
"\n",
"def regression(X, W):\n",
" \"\"\"calcula la regresión multiple\n",
" X: los valores que corresponden a las caractersiticas\n",
" W: son los pesos usadados para realizar la regresión\n",
" retorna: valor estimado\n",
" \"\"\" \n",
" Yest = np.dot(X,W) #con np.dot se realiza el producto matricial. Aquí X es dim [Nxd] y W es dim [dx1]\n",
" return Yest #Esta variable contiene la salida de f(X,W)\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "oWEgqHRyt-Dg"
},
"source": [
"De igual manera, debemos extender nuestro conjunto de datos. Comprende que hace la siguiente celda de código y ejecutala. **Muy importante ejecutar SOLA UNA vez.**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "YzAgbcZyt-Dh"
},
"outputs": [],
"source": [
"#Aca llamamos la funcion creada anteriormente\n",
"# par obtener el numero muestras y caractersiticas\n",
"muestras,caracterisitcas = num_muestras_carac(x)\n",
"#Extendemos la matriz de X para el parámetro independiente\n",
"unos = np.array([np.ones(muestras)])\n",
"x = np.concatenate((unos.T, x), axis=1)\n",
"x = x.reshape(muestras, caracterisitcas+1)\n",
"y = y.reshape(np.size(y), 1)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"cellView": "form",
"colab": {},
"colab_type": "code",
"id": "xz6ZrNhWt-Di"
},
"outputs": [],
"source": [
"#@title Pregunta Abierta\n",
"#@markdown ¿por es necesario realizar la anterior extensión a nuestro conjunto de datos?\n",
"respuesta_2 = \"\" #@param {type:\"string\"}"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "792kf6-pt-Dk"
},
"source": [
"Ahora vamos a completar el código de la regla de actualización de los parámetros del algoritmo de gradiente_descedente: \n",
"\n",
"$$w_j(iter) = w_j(iter-1) - \\eta \\frac{\\partial E(w)}{\\partial w_j}$$ \n",
"\n",
"recordar que \n",
"\n",
"$$ \\frac{\\partial E(w)}{\\partial w_j} = \\frac{\\partial E({\\bf{w}})}{\\partial w_j} = \\frac{1}{N}\\sum_{i=1}^{N}\\left( f({\\bf{x}}_i,{\\bf{w}}) - y_i\\right) \\frac{\\partial }{\\partial w_j} f({\\bf{x}}_i, {\\bf{w}})$$\n",
"\n",
"recuerda que debe usar las funciones ya implementadas y no usar **ninguna otra libreria**, adicional a las librerias ya pre-cargadas como numpy (la puedes llamar con np.)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "LTh-Fn3Ft-Dl"
},
"outputs": [],
"source": [
"## Ejercicio de codigo\n",
"def gradiente_descendente(X, Y, eta, iteraciones):\n",
" \"\"\"Gradiente descendente para regresión lineal múltiple\n",
" X: Matriz de datos extendida\n",
" Y: vector con los valores a predecir\n",
" W: Vector de parámetros del modelo\n",
" eta: Taza de aprendizaje\n",
"\n",
" retorna: W el valor de de los parametros de regresión polinomica\n",
" \"\"\"\n",
" \n",
" #Inicializamos el vector de parámetros con ceros y suamos la función\n",
" # para saber el numero de muestras y caractersiticas\n",
" N, caracterisitcas = num_muestras_carac(X)\n",
" W = np.zeros((1,caracterisitcas))\n",
" W = W.reshape(np.size(W), 1) \n",
"\n",
" for iter in range(iteraciones):\n",
" ## Aca debes completar la funcion! recuerda que solo debes usar numpy (np.funcion_a_usar)\n",
" ## para actualizar los pesos W.\n",
" ## Pista: consulta que efecto tienen los parametros keepdims y axis en np.sum()\n",
"\n",
" W =\n",
" \n",
" return W"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "JhwNveWct-Dm",
"tags": []
},
"outputs": [],
"source": [
"## la funcion que prueba tu implementacion\n",
"GRADER_LAB_1_P1.run_test(\"ejercicio2\", gradiente_descendente)"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "SKjx_cyit-Do"
},
"source": [
"### Ejercicio 3: Entrenamiento\n",
"\n",
"Con la función implementada vamos a entrenar un modelo y calcular su error de entrenamiento. Antes de realizar esto, debemos separar nuestro conjunto de datos.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "sS9hJDVFt-Do"
},
"outputs": [],
"source": [
"# esto para lograr reproductibilidad\n",
"# de nuestro modelo\n",
"random.seed(1)\n",
"# usamos nuestra funcion para obtener el numero de muestras\n",
"N, _ = num_muestras_carac(x)\n",
"ind=np.random.permutation(N)\n",
"Xtrain = x[ind[0:int(math.ceil(0.7*N))],:]\n",
"Xtest = x[ind[int(math.ceil(0.7*N)):N],:]\n",
"Ytrain = y[ind[0:int(math.ceil(0.7*N))]]\n",
"Ytest = y[ind[int(math.ceil(0.7*N)):N]]"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "WirOVVB3t-Dq"
},
"source": [
"Ahora entrena ejecutando la siguiente linea de codigo"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "0yZA7wcCt-Dr",
"tags": []
},
"outputs": [],
"source": [
"W = gradiente_descendente(Xtrain, Ytrain, eta = 0.0001, iteraciones=5)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"cellView": "form",
"colab": {},
"colab_type": "code",
"id": "wjSZoGRat-Ds"
},
"outputs": [],
"source": [
"#@title Pregunta Abierta\n",
"#@markdown ¿por qué fue necesario dividir nuestro conjunto de datos? justifique su respuesta \n",
"respuesta_3 = \"\" #@param {type:\"string\"}"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "vzdmfgTXt-Du"
},
"source": [
"Vamos a evaluar nuestro modelo calculando el error cuadrático medio. Para ello vamos crear a una función. Recuerda usar las funciones definidas anteriormente."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "oi2YMyITt-Du"
},
"outputs": [],
"source": [
"## Ejercicio de Código\n",
"def evaluar_modelo (W, X_to_test, Y_True):\n",
" \"\"\" funcion que evalua un modelo de regresión usando el error cuadratico medio\n",
"\n",
" W: es un matriz con los parametros del modelo entrenados\n",
" X_to_test: conjunto de datos para usar en el evaluamiento del modelo\n",
" Y_True: valores reales para usar en el evaluamiento del modelo\n",
"\n",
" retorna: el error cuadratico medio\n",
" \"\"\"\n",
" ## Comienza a completar tu codigo. recuerda usar la funciones ya definidas\n",
"\n",
" return(error)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "5J2Y2CR0t-Dw",
"tags": []
},
"outputs": [],
"source": [
"## la funcion que prueba tu implementacion\n",
"GRADER_LAB_1_P1.run_test(\"ejercicio3\", evaluar_modelo)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "SkVgkc_5t-Dy",
"tags": []
},
"outputs": [],
"source": [
"# y ahora usala para calcular el error, para evaluar el modelo\n",
"error_train = evaluar_modelo(W, X_to_test = Xtrain, Y_True = Ytrain)\n",
"print(\"error en entrenamiento del modelo\", error_train)\n",
"error_test = evaluar_modelo(W, X_to_test = Xtest, Y_True = Ytest)\n",
"print(\"error en la evaluación del modelo\", error_test)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"cellView": "form",
"colab": {},
"colab_type": "code",
"id": "Dy9Ft9cJt-D0"
},
"outputs": [],
"source": [
"#@title Pregunta Abierta\n",
"#@markdown ¿que conjunto de datos se uso para evaluar el modelo (cual fue el conjunto de datos asignado a X_to_test para el error test)? justifica tu respuesta\n",
"respuesta_4 = \"\" #@param {type:\"string\"}"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"cellView": "form",
"colab": {},
"colab_type": "code",
"id": "50C2ZAubt-D2"
},
"outputs": [],
"source": [
"#@title Pregunta Abierta\n",
"#@markdown escribe aqui tu error al evaluar el modelo con tres cifras decimales. ¿Que tan bueno es tu modelo? Justifica tu respuesta.\n",
"respuesta_5 = \"\" #@param {type:\"string\"}\n"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "pq729RWGt-D3"
},
"source": [
"Hasta ahora lo que hemos realizado es un regresión lineal no polinómica. Nuestro siguiente objetivo es tomar esta regresión y transformarla en polinómica. Comprenda el funcionamiento de la función propuesta"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "3OU0ZVLut-D3"
},
"outputs": [],
"source": [
"#Potencia de polinomio\n",
"def potenciaPolinomio(X,grado):\n",
" \"\"\"calcula la potencia del polinomio\n",
" X: los valores que corresponden a las caractersiticas\n",
" grado: esl grado para realizar la potencia al polinomio\n",
" retorna: el valor de X despues elevarlo al grado del polinimoo indicado\n",
" \"\"\"\n",
" X2 = X.copy()\n",
" \n",
" if grado != 1:\n",
" for i in range(2,grado+1):\n",
" Xadd = X**i\n",
" X2 = np.concatenate((X2, Xadd), axis=1)\n",
" \n",
" return X2"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "N37UeA5mt-D5"
},
"source": [
"ahora debemos usar esta función para completar la siguiente, recuerda que puedes reusar funciones desarrolladas anteriomente"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "lJd2w7ezt-D5"
},
"outputs": [],
"source": [
"## Ejercicio de codigo\n",
"def gradiente_descendente_poly (X, Y, eta, iteraciones, grado):\n",
" \"\"\"Gradiente descendente para regresión lineal múltiple\n",
" X: Matriz de datos extendida\n",
" Y: vector con los valores a predecir\n",
" W: Vector de parámetros del modelo\n",
" eta: Taza de aprendizaje\n",
" iteraciones: numero de iteraciones maximo para el gradiente\n",
" grado: el valor del polinomio a usar\n",
" retorna: W el valor de de los parametros de regresión polinomica\n",
" \"\"\"\n",
" X2 = potenciaPolinomio(X,grado)\n",
" ## completa el codigo\n",
"\n",
" return (W)\n",
"\n",
"def evaluar_modelo_poly (W, X_to_test, Y_True, grado):\n",
" \"\"\" funcion que evalua un modelo de regresión usando el error cuadratico medio\n",
"\n",
" W: es un matriz con los parametros del modelo entrenados\n",
" X_to_test: conjunto de datos para usar en el evaluamiento del modelo\n",
" Y_True: valores reales para usar en el evaluamiento del modelo\n",
" grado: grado del polinimio a usar\n",
"\n",
" retorna: el error cuadratico medio\n",
" \"\"\"\n",
" ## Comienza a completar tu codigo. recuerda usar la funciones ya definidas\n",
" X2 = potenciaPolinomio(X_to_test,grado)\n",
" \n",
" return(error)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "ji7q97o1t-D7",
"tags": []
},
"outputs": [],
"source": [
"## la funcion que prueba tu implementacion\n",
"GRADER_LAB_1_P1.run_test(\"ejercicio4\", gradiente_descendente_poly)\n",
"GRADER_LAB_1_P1.run_test(\"ejercicio5\", evaluar_modelo_poly)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "FYhz7MRIt-D8",
"tags": []
},
"outputs": [],
"source": [
"# entrenamos\n",
"W = gradiente_descendente_poly(Xtrain, Ytrain, eta = 0.0001, iteraciones=2, grado = 2)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "CYMnh6n7t-EA",
"tags": []
},
"outputs": [],
"source": [
"# completa los parametros para evaluar el modelo\n",
"error_test = evaluar_modelo_poly(W, X_to_test = Xtest, Y_True = Ytest, grado = 2)\n",
"print(\"error en la evaluación del modelo\", error_test)"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "5pBn_Tt6t-EC"
},
"source": [
"### Ejercicio 4: Experimentar\n",
"\n",
"En nuestro primer experimento vamos a evaluar el rendimiento del modelo usando varias tasas de aprendizaje y grados de polinimios. Vamos a dejar por ahora un numero de iteraciones fijas = 5. Para ello completa la siguiente función.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "ALxnYTFTt-EC"
},
"outputs": [],
"source": [
"## ejercicio de codigo\n",
"def experimentar (Xtrain, Xtest, Ytrain, Ytest, tasas, grados):\n",
" \"\"\" funcion para realizar experimentos.\n",
" Xtrain: conjunto de datos\n",
" Xtest:\n",
" Ytrain:\n",
" Ytest:\n",
" tasas: Es una lista con los valores númericos de tasas de aprendizaje \n",
" para realizar los experimentos\n",
" grados: Es una lista con los valores númericos de grados \n",
" para realizar los experimentos\n",
" retorna: un dataframe con el resultados de los experimentos\n",
" \"\"\"\n",
" numero_iter = 5\n",
"\n",
" resultados = pd.DataFrame()\n",
" idx = 0 # indice\n",
" for eta in tasas:\n",
" for grado in grados:\n",
"\n",
" W =\n",
" error =\n",
" \n",
" resultados.loc[idx,'grado'] = grado\n",
" resultados.loc[idx,'tasa de aprendizaje'] = eta\n",
" resultados.loc[idx,'ecm'] = error\n",
" idx = idx+1\n",
"\n",
" return (resultados)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "dKC_CnY1t-EE",
"tags": []
},
"outputs": [],
"source": [
"## la funcion que prueba tu implementacion\n",
"GRADER_LAB_1_P1.run_test(\"ejercicio6\", experimentar)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "8oxa-XkKt-EF",
"tags": []
},
"outputs": [],
"source": [
"## Ahora usa para verlos los resultados\n",
"tasas_aprendizaje = [1e-6, 1e-5, 1e-3, 1e-2]\n",
"grados_polinomio = [1,2,3]\n",
"resultados_ex1 = experimentar(Xtrain, Xtest, Ytrain, Ytest, tasas_aprendizaje, grados_polinomio)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "zAOcZfoRt-EG",
"tags": []
},
"outputs": [],
"source": [
"#para ver los resultados\n",
"resultados_ex1"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "yoDS2e-gt-EI"
},
"source": [
"Si has implementado todo correctamente, parecieria que nuestros entrenamientos no esta logrando buenos resultados (hasta parece haber errores infinitos! o no determinados!). Ahora Entiende la siguiente función. \n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "IhHXjgOmt-EI"
},
"outputs": [],
"source": [
"#Normalizamos los datos\n",
"def normalizar(Xtrain, Xtest):\n",
" \"\"\" función que se usa para normalizar los datos con\n",
" un metodo especifico\n",
" Xtrain: matriz de datos entrenamiento a normalizar\n",
" Xtest: matriz de datos evaluación a normalizar\n",
" retorna: matrices normalizadas\n",
" \"\"\"\n",
" \n",
" media = np.mean(Xtrain, axis = 0)\n",
" desvia = np.std(Xtrain, axis = 0)\n",
" Xtrain_n = stats.stats.zscore(Xtrain)\n",
" Xtest_n = (Xtest - media )/desvia\n",
" # si hay una desviacion por cero, reemplazamos los nan\n",
" Xtrain_n = np.nan_to_num(Xtrain_n)\n",
" Xtest_n = np.nan_to_num(Xtest_n)\n",
" return (Xtrain_n, Xtest_n)"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "PzsHpPk1t-EK"
},
"source": [
"Ahora vuelve a realizar los mismos experimentos pero esta vez usa los valores de salida de la función anterior."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "ZZedE9Qdt-EK",
"tags": []
},
"outputs": [],
"source": [
"Xtrain_n, Xtest_n = normalizar(Xtrain, Xtest)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "j2a8O7c7t-EM",
"tags": []
},
"outputs": [],
"source": [
"resultados_ex2 = experimentar(Xtrain_n, Xtest_n, Ytrain, Ytest, tasas_aprendizaje, grados_polinomio)\n",
"#para ver los resultados\n",
"resultados_ex2"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "CANS0MVut-EO"
},
"outputs": [],
"source": [
"# ejecuta esta linea de codigo para ver graficamos tus resultados\n",
"# aca usamos una libreria llamada seaborn\n",
"import seaborn as sns\n",
"s = sns.catplot(data = resultados_ex2, x = 'tasa de aprendizaje',\n",
" y = 'ecm',hue ='grado', kind = 'bar', )\n",
"s.set(yscale=\"log\")"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "LLvDR6k5t-EQ"
},
"source": [
"Ten en cuenta el resutaldo de los dos experimentos y responde la siguiente pregunta abierta"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"cellView": "form",
"colab": {},
"colab_type": "code",
"id": "aVFbsu0wt-EQ"
},
"outputs": [],
"source": [
"#@title Pregunta Abierta\n",
"#@markdown ¿Qué proceso hace la normalización sobre los datos? Consulte por qué es necesaria la normalización en el modelo de regresión y cuáles son los tipos de normalización más comunes. ¿Cuál de ellos se aplicó en el laboratorio?\n",
"respuesta_5 = \"\" #@param {type:\"string\"}"
]
},
{
"cell_type": "markdown",
"metadata": {
"colab_type": "text",
"id": "1Z3nka5at-ES"
},
"source": [
"Finalmente, en nuestro tercer experimento, vamos ver el efecto de las iteraciones sobre el error. completa la siguiente función. Esta vez la tasa de aprendizaje es constante"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "i2eHfZC9t-ES",
"tags": []
},
"outputs": [],
"source": [
"## ejercicio de codigo\n",
"def experimentar_2 (Xtrain, Xtest, Ytrain, Ytest, iteraciones, grados):\n",
" \"\"\" funcion para realizar experimentos.\n",
" Xtrain: conjunto de datos\n",
" Xtest:\n",
" Ytrain:\n",
" Ytest:\n",
" tasas: Es una lista con los valores númericos de tasas de aprendizaje \n",
" para realizar los experimentos\n",
" rangos: Es una lista con los valores númericos de grados \n",
" para realizar los experimentos\n",
" retorna: un dataframe con el resultados de los experimentos\n",
" \"\"\"\n",
" eta = 1e-2\n",
" resultados = pd.DataFrame()\n",
" idx = 0 # indice\n",
" for iter in iteraciones:\n",
" for grado in grados:\n",
" W = \n",
" error = \n",
" \n",
" resultados.loc[idx,'iteraciones'] = iter\n",
" resultados.loc[idx,'grado'] = grado\n",
" resultados.loc[idx,'ecm'] = error\n",
" idx = idx+1\n",
" return (resultados)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "1Q3TALf8t-ET",
"tags": []
},
"outputs": [],
"source": [
"## la funcion que prueba tu implementacion\n",
"GRADER_LAB_1_P1.run_test(\"ejercicio7\", experimentar_2)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "GZIKf7PIt-EV",
"tags": []
},
"outputs": [],
"source": [
"num_iters = [1,5,10,20,50, 100,200]\n",
"grados_polinomio = [1,2]\n",
"# usamos la funcion para evaliar los resultados\n",
"resultados_ex3 = experimentar_2(Xtrain_n, Xtest_n, Ytrain, Ytest, num_iters, grados_polinomio )"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "E5ekonH6t-EW"
},
"outputs": [],
"source": [
"# ejecuta esta linea de codigo para ver raficamente tus resultados\n",
"# aca usamos una libreria llamada seaborn\n",
"import seaborn as sns\n",
"sns.relplot(data = resultados_ex3, x = 'iteraciones',\n",
" y = 'ecm',col ='grado', kind = 'line')"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"cellView": "form",
"colab": {},
"colab_type": "code",
"id": "Y0-BAqdgt-EY"
},
"outputs": [],
"source": [
"#@title Pregunta Abierta\n",
"#@markdown ¿con base a los resultados anteriores, qué efecto tiene el numero de iteraciones en el error?\n",
"respuesta_6 = \"\" #@param {type:\"string\"}"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"cellView": "form",
"colab": {},
"colab_type": "code",
"id": "NDfO1dvJt-Eb"
},
"outputs": [],
"source": [
"#@title Pregunta Abierta\n",
"#@markdown ¿que efecto tiene el grado del polinomio en el ECM?\n",
"respuesta_7 = \"\" #@param {type:\"string\"}"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "gkLeD-pMuk_g"
},
"outputs": [],
"source": [
"GRADER_LAB_1_P1.check_tests()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"cellView": "form",
"colab": {},
"colab_type": "code",
"id": "Xz0gLt5At-Ec"
},
"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": "C_jp0Yjot-Ee"
},
"source": [
"----\n",
"esta linea de codigo va fallar, es de uso exclusivo del los profesores\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"colab": {},
"colab_type": "code",
"id": "OxiTM5g7t-Ef"
},
"outputs": [],
"source": [
"GRADER_LAB_1_P1.grade()"
]
}
],
"metadata": {
"colab": {
"name": "lab1_parte1.ipynb",
"provenance": [],
"toc_visible": true
},
"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": 2
}