Aprendamos lo elemental
GUSTAVO GALVIS
student•
hace 4 años
Eduardo Monzón
student•
hace 2 años
GUSTAVO GALVIS
Eduardo Monzón
DIEGO ALEXANDER CASTELLANOS SANTAMARIA
Carlos Mazzaroli
María Eugenia Pereira Chévez
Antonio Demarco Bonino
David Alidhasem Manzanares Casio
Joel Angel David Barrantes Palacios
Osvaldo Olguín
Daniel Alejandro Franco Meneses
frank hurtado
Jorge Andres Alvarez Ore
Jeinfferson Bernal G
Iván Frías Gil
Naren Fragozo
Arelys Viloria
Kevin Toruño
Robert Yesid Barrios Acendra
Braulio Alejo Aguilar
Victor Bocanegra Eugenio
Jeinfferson Bernal G
Fernando Callasaca Acuña
Carlos Mazzaroli
Rene Rosas
Carlos Mazzaroli
Andyno Cortez
Isaac Bryan Ascanoa Roncall
ECM: El error cuadrático medio (mean squared error) mide el promedio de los errores elevados al cuadrado. Es útil para validar que tan precisa es la predicción obtenida (desempeño del modelo).
Excelente, gracias por el aporte, no olvides que el error es medido para la misma ordenada, es decir, en el gráfico el error señalado en rojo es una línea vertical.
bueno, pero que paso? no solucionó la ecuación al modo, solo puso las formulas y ya, creo que no demoraba ni unos 5 minutos en eso.
Creo que la idea estas ultimas dos clases es que hagamos las cosas solitos, pero si necesitaste ayuda acá te dejo 1 de las muchas formas que se puede resolver
Calcular R.Lineal
import numpy as np import pandas as pd import matplotlib.pyplot as plt x = np.array([1.2, 2, 3.2, 2.5, 5, 6, 4, 8]) y = np.array([2, 3, 3.4, 3.1, 4, 4.7, 3.8, 7]) n = len(x) xy = np.sum((x*y),axis=0) x_2 = np.sum((x**2), axis=0) sum_x = np.sum(x, axis=0) sum_y = np.sum(y, axis=0) def m(): numerador = (n*xy) - (sum_x * sum_y) denominador = (n*x_2) - (sum_x**2) return np.divide(numerador,denominador) m = m() def b(): numerador = sum_y - (m * sum_x) denominador = n return np.divide(numerador, denominador) b = b() def f(): return (m*x)+b y_prima = f() # Estos es para ver los resultados noams xD df = pd.DataFrame.from_dict({ "xy" :xy, "x_2" :x_2, "sum_x" :sum_x, "sum_y" :sum_y, "m" :m, "b" :b, "y_prima" :y_prima, },) df.head(1)
Graficar
plt.scatter(x,y) plt.plot(x,y_prima, '--') plt.xlabel('x1000\npublicidad') plt.ylabel('ganancias') plt.grid() plt.xlim(0,10) plt.ylim(0,10)
Error Cuadratico Medio
sum_y_prima = np.sum(y_prima, axis=0) def MSE(): return (1/n) * np.sum((y - y_prima)**2, axis=0) mse = MSE() print(f""" mse {mse} """)
Graficando y resolviendo el ECM del ejemplo:
x= np.array([1.2,2,3.2,2.5,5,6,4,8]) y= np.array([2,3,3.4,3.1,4,4.7,3.8,7]) fig, ax = plt.subplots() plt.scatter(x,y, color = 'blue', alpha=0.6) #Vamos agregarle a nuestra x el término independiente de 1s #Vamos a crear una nueva matriz creada por x, con la cantidad de filas de la matriz x X= np.array([np.ones(8),x]).T Y = y # @ se usa para multiplicar matrices B = np.linalg.inv(X.T @ X ) @ X.T @ Y ax.plot([1,8],[B[0]+B[1]*1,B[0]+B[1]*8], c="red") plt.title('Regresión Lineal') ax.set_xlabel('x',fontsize=16) ax.set_ylabel('y',fontsize=16) plt.show()
Nuestra matriz de resultado debería de tener por lo menos dos elementos:
ax.plot([1,8],[B[0]+B[1]*1,B[0]+B[1]*8], c="red")
El primer punto (1,8) lo definimos nosotros y el segundo término B[0] es el término independiente +B[1] todo multiplicado por el valore de x que seleccionamos que en este caso es 1. Igual para el segundo.
Aunque lo normal es aplicar directamente la regresión lineal con una librería.
Una clase maravillosa que no hace otra cosa que abrir la cabeza a diferentes posibilidades y oportunidades.
Creo que hay un error en el examen final. Uno de los cuestionamientos es que si las variables discretas pueden formar un conjunto infinito y la respuesta es si. Sin embargo, la respuesta que se da por válida es la contraria. . Los números naturales son un conjunto discreto e infinito. . Lo que es efectivamente falso, es que entre dos valores cualesquiera de una variable discreta no puede existir un número infinito de otros valores.
veo que lo corrigieron en el examen
Los números reales sí son un conjunto infinito
Les comparto la comparación entre una regresión lineal simple y una regresión polinomial de grado 3.
Cómo podemos ver el polinomio de grado 3 se ajusta mejor a los datos, pero debemos tener cuidado en no caer en un overfiting.
con esta grafica podemos observas un poco mas alla para interpretar un error y saber si somos precisos o si somos exactos
saludos
Esa fórmula y concepto lo conozco desde años, pero primera vez que logro ver y entender su razonamiento detrás, haciéndolo poder memorizarlo pues es más fácil entendiendo lo gráficamente.
Concuerdo contigo. Tambien primera vez que lo logro entender a profundidad
Esta clase es un espectáculo, de verdad, son las matemáticas aplicadas a casos reales, me ha encantado
El error se calcula como la diferencia entre el valor real y el valor previsto por un modelo. En un sentido más general, el error mide la precisión de un modelo en la predicción de datos.
Hay muchas formas de calcular el error, dependiendo del tipo de problema y de la métrica de precisión que se desee utilizar. Aquí hay algunos ejemplos comunes de cálculo de error:
Error cuadrático medio (MSE): Este es el promedio de la suma de los errores cuadrados entre el valor real y el valor previsto, y se utiliza comúnmente en problemas de regresión.
Error absoluto medio (MAE): Este es el promedio de la suma de los errores absolutos entre el valor real y el valor previsto, y se utiliza comúnmente en problemas de regresión.
Exactitud: Este es el porcentaje de predicciones correctas que hace un modelo en un problema de clasificación. En cualquier caso, el objetivo es minimizar el error para mejorar la precisión del modelo.
Calcular el error en regresión lineal 💚📝:
Aquí medimos que tan lejos estamos de los datos independientes observables de la predicción del modelo, la diferencia entre estas dos variables será el error. Como puedes ver en el siguiente gráfico, el valor independiente observable se encuentra en 30 en el eje Y, mientras que el valor predicho se encuentra en 25, a esa diferencia la conocemos como el error.
error = ȳ - Y
Pero esta función está incompleta y por si sola no es precisa porque para que funcione correctamente necesitamos pasarle número positivos, por lo que se le agrega el valor absoluto, formula que sirve para volver un valor negativo a positivo:
| error | = ( ȳ - Y)
Otra forma de conseguir esto es elevando la función al cuadrado, como es obvio siempre te va a regresar un valor positivo.
error^2 = (ȳ -Y)^2
Por lo tanto si nosotros envelaremos al cuadrado el error este se duplica dentro de la gráfica, y mientras más grande sea el error más impacto va a tener porque el error será muy grande, si es muy muy pequeño el error apenas habrá una diferencia en comparación con los errores más grandes.
Pero no nos interesa saber el error de solo un punto, así que para calcular el error total en todos los valores que tengamos de forma total usaremos:
Error Total = Σ(yi - ŷ)^2
Pero para calcular el Error Cuadrático Medio de todos los puntos usaremos:
ECM = (1/n) * Σ(yi - ȳ)^2
Amé tu resumen, gracias :)
"Va a ser positivo, pero se va a duplicar" Es incorrecto decir que se va a duplicar, tal vez se le fue la liebre, más al ver el 2 como exponente. El error es una distancia, una longitud, como lo puden ver ahí; el error al cuadrado gráficamente sería el área de un cuadradado. El error cuadrático medio que busca elaborar aquí es una sumatoria de todos esos cuadrados, más grandes, más pequeños, pero son cuadrados al fin y al cabo, luego divididos por la cantidad de cuadrados que hay (n) y luego la raíz cuadrada, que lo vuelve a convertir en lo que era: una longitud.
Las funciones de coste son una parte importante en el aprendizaje automático y el proceso de entrenamiento de un modelo. Se utilizan para evaluar el rendimiento de un modelo en términos de su capacidad para realizar una tarea específica, como la predicción de un valor dado o la clasificación de un conjunto de datos.
Hay muchas funciones de coste diferentes que se pueden utilizar en el aprendizaje automático, y la elección de la adecuada depende del tipo de problema que se esté tratando y del tipo de modelo que se esté utilizando. Algunas de las funciones de coste más comunes son:
Error cuadrático medio (MSE, por sus siglas en inglés): Esta función de coste mide la diferencia entre los valores pronosticados por el modelo y los valores reales. Se calcula como la media del cuadrado de la diferencia entre los valores pronosticados y los reales. Es comúnmente utilizada en problemas de regresión. Entropía cruzada: Esta función de coste se utiliza a menudo en problemas de clasificación. Mide la diferencia entre las probabilidades predicadas por el modelo y las probabilidades reales. Logaritmo de verosimilitud: Esta función de coste también se utiliza a menudo en problemas de clasificación. Mide la probabilidad de que el modelo genere los datos que se le proporcionaron durante el entrenamiento. Hinge loss: Esta función de coste se utiliza a menudo en problemas de clasificación binaria y en modelos de aprendizaje por refuerzo. Mide la diferencia entre la predicción del modelo y el valor real.
Es importante tener en cuenta que, aunque estas son algunas de las funciones de coste más comunes, hay muchas otras disponibles y que pueden ser adecuadas para diferentes problemas y modelos.
Aquí el código para obtener el modelo de Regresión Lineal y cómo graifcarlo:
# Importando las librerías import numpy as np import pandas as pd import matplotlib.pyplot as plt from sklearn.linear_model import LinearRegression # Colocando nuestros datos en forma de array x = np.array([1.2, 2, 3.2, 2.5, 5, 6, 4, 8]) y = np.array([2, 3, 3.4, 3.1, 4, 4.7, 3.8, 7]) # Cargando el modelo de Regresión Lineal model = LinearRegression() # Es necesario hacer un reshape, porque nuestros datos (x) consisten en varias muestras con una sola característica model.fit(x.reshape(-1, 1), y) # Hacemos un nuevo array x_hat y y_hat que nos permitirá graficar los puntos de la recta x_hat = np.linspace(1.2, 8, 1000) y_hat = model.predict(x_hat.reshape(-1, 1)) # Graficando los datos y el modelo obtenido plt.scatter(x,y) plt.plot(x_hat, y_hat, '--', color = 'r') plt.grid(linewidth = .6) plt.ylabel('Ingresos') plt.xlabel('Publicidad') plt.legend(['Modelo de RL', 'Datos reales']) plt.show()
Las funciones de errores tambien se conocen como funcion de coste
La mejor clase de entre todas.
Resolucion con Numpy
Calcular R.Lineal
import numpy as np import pandas as pd import matplotlib.pyplot as plt x = np.array([1.2, 2, 3.2, 2.5, 5, 6, 4, 8]) y = np.array([2, 3, 3.4, 3.1, 4, 4.7, 3.8, 7]) n = len(x) xy = np.sum((x*y),axis=0) x_2 = np.sum((x**2), axis=0) sum_x = np.sum(x, axis=0) sum_y = np.sum(y, axis=0) def m(): numerador = (n*xy) - (sum_x * sum_y) denominador = (n*x_2) - (sum_x**2) return np.divide(numerador,denominador) m = m() def b(): numerador = sum_y - (m * sum_x) denominador = n return np.divide(numerador, denominador) b = b() def f(): return (m*x)+b y_prima = f() # Estos es para ver los resultados noams xD df = pd.DataFrame.from_dict({ "xy" :xy, "x_2" :x_2, "sum_x" :sum_x, "sum_y" :sum_y, "m" :m, "b" :b, "y_prima" :y_prima, },) df.head(1)
Graficar
plt.scatter(x,y) plt.plot(x,y_prima, '--') plt.xlabel('x1000\npublicidad') plt.ylabel('ganancias') plt.grid() plt.xlim(0,10) plt.ylim(0,10)
Error Cuadratico Medio
sum_y_prima = np.sum(y_prima, axis=0) def MSE(): return (1/n) * np.sum((y - y_prima)**2, axis=0) mse = MSE() print(f""" mse {mse} """)
pero y cuando se aplica la teoria practicamente? nunca vimos como calcular la linea de prediccion o cuales son los resultados del error de dicha linea. Para mi esta como clase incompleta. Para la gente que tiene un background de matematicas fuerte es muy simple e intuitivo o incluso les puede resultar muy basico la clase. Pero para los que nuestro conocimientos matematicos son basicos a mi no me resulve la pregunta del titulo de la clase de '¿Como se calcula un error?'
Calcular R.Lineal
import numpy as np import pandas as pd import matplotlib.pyplot as plt x = np.array([1.2, 2, 3.2, 2.5, 5, 6, 4, 8]) y = np.array([2, 3, 3.4, 3.1, 4, 4.7, 3.8, 7]) n = len(x) xy = np.sum((x*y),axis=0) x_2 = np.sum((x**2), axis=0) sum_x = np.sum(x, axis=0) sum_y = np.sum(y, axis=0) def m(): numerador = (n*xy) - (sum_x * sum_y) denominador = (n*x_2) - (sum_x**2) return np.divide(numerador,denominador) m = m() def b(): numerador = sum_y - (m * sum_x) denominador = n return np.divide(numerador, denominador) b = b() def f(): return (m*x)+b y_prima = f() # Estos es para ver los resultados noams xD df = pd.DataFrame.from_dict({ "xy" :xy, "x_2" :x_2, "sum_x" :sum_x, "sum_y" :sum_y, "m" :m, "b" :b, "y_prima" :y_prima, },) df.head(1)
Graficar
plt.scatter(x,y) plt.plot(x,y_prima, '--') plt.xlabel('x1000\npublicidad') plt.ylabel('ganancias') plt.grid() plt.xlim(0,10) plt.ylim(0,10)
Error Cuadratico Medio
sum_y_prima = np.sum(y_prima, axis=0) def MSE(): return (1/n) * np.sum((y - y_prima)**2, axis=0) mse = MSE() print(f""" mse {mse} """)
Otras funciones que siempre te da positivo:
Interesante el uso de calculo de errores lineales. Si que hay mucho por aprender. Lo bueno es que es entretenido e interesante.