¿Cómo se calcula un error?

Clase 17 de 18 • Curso de Funciones Matemáticas para Data Science e Inteligencia Artificial

Contenido del curso

Aprendamos lo elemental

Todo sobre funciones

Funciones en ciencia de datos

Modela tu primer función

Este no es el fin

18
Te has iniciado detrás del secreto de la ciencia de datos
02:22 min

Tomar examen

Comentarios

GUSTAVO GALVIS

student•

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).

Eduardo Monzón

student•

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.

DIEGO ALEXANDER CASTELLANOS SANTAMARIA

student•

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.

Carlos Mazzaroli

student•

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}
""")

María Eugenia Pereira Chévez

student•

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:

elemento independiente de nuestra línea, que representa el punto del Y que se corta cuando X=0.
la pendiente que nos indica que cada incremento en la publicidad tenemos un incremento en la venta.

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.

Diego Ortiz

student•

Muy abstracto, hoy en día se dice que es más común usar Scikit-Learn:

from sklearn.linear_model import LinearRegression

# Scikit-learn espera que X sea una matriz (2D), por eso usamos .reshape(-1, 1)
X = x.reshape(-1, 1) 
Y = y

# Creamos y entrenamos el modelo
modelo = LinearRegression()
modelo.fit(X, Y)

fig, ax = plt.subplots()
ax.plot([1,8],[modelo.coef_[0]+modelo.intercept_*1,modelo.coef_[0]+modelo.intercept_*8], c="red")

O podrías explicar que tu B es la función error o función de coste B = (X.T @ X)^-1 @ X.T @ Y

Que es el resultado de derivar (optimizar), en forma de matrices, la fórmula que formuló el profe en esta clase.

Antonio Demarco Bonino

student•

Una clase maravillosa que no hace otra cosa que abrir la cabeza a diferentes posibilidades y oportunidades.

David Alidhasem Manzanares Casio

student•

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.

Joel Angel David Barrantes Palacios

student•

veo que lo corrigieron en el examen

Osvaldo Olguín

student•

Los números reales sí son un conjunto infinito

Daniel Alejandro Franco Meneses

student•

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.

Jorge Andres Alvarez Ore

student•

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.

Jeinfferson Bernal G

student•

Concuerdo contigo. Tambien primera vez que lo logro entender a profundidad

frank hurtado

student•

con esta grafica podemos observas un poco mas alla para interpretar un error y saber si somos precisos o si somos exactos

!exactitud vs precision

saludos

Iván Frías Gil

student•

Esta clase es un espectáculo, de verdad, son las matemáticas aplicadas a casos reales, me ha encantado

Naren Fragozo

student•

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.

Anthony Marimón Díaz

student•

Hacer esto a lápiz y papel es mil veces mejor para dominar esto. Las herramientas como Python, R, SQL solo facilitaran implementarlo.

Por eso, es importante que estos cursos sean al principio con ese enfoque (a lápiz, y papel), y a lo último explicar que herramientas (Python, SQL, Excel, R) podemos implementarlo.

Arelys Viloria

student•

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.

Entonces la función para calcular el error será la predicción menos los datos reales.

	  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

Nota: creo que la importante aquí es la ECM, ten esa en cuenta

Kevin Toruño

student•

Amé tu resumen, gracias :)

Robert Yesid Barrios Acendra

student•

"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.

Braulio Alejo Aguilar

student•

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.

Victor Bocanegra Eugenio

student•

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()

Jeinfferson Bernal G

student•

Las funciones de errores tambien se conocen como funcion de coste

Fernando Lucena

student•

Excelente explicación de regresión lineal: https://www.youtube.com/watch?v=EE2a2Cr-JfY

Fernando Callasaca Acuña

student•

La mejor clase de entre todas.

Carlos Mazzaroli

student•

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}
""")

Rene Rosas

student•

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?'

Carlos Mazzaroli

student•

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}
""")

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)

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()

from sklearn.linear_model import LinearRegression

# Scikit-learn espera que X sea una matriz (2D), por eso usamos .reshape(-1, 1)
X = x.reshape(-1, 1) 
Y = y

# Creamos y entrenamos el modelo
modelo = LinearRegression()
modelo.fit(X, Y)

fig, ax = plt.subplots()
ax.plot([1,8],[modelo.coef_[0]+modelo.intercept_*1,modelo.coef_[0]+modelo.intercept_*8], c="red")

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.

# 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()

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)

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)

¿Cómo se calcula un error?

Aprendamos lo elemental

Necesitas aprender sobre funciones

¿Qué es una función?

Tipos de variables

Qué es el dominio y rango en funciones

Cómo leer las matemáticas: Símbolos generales

Cómo leer las matemáticas: Conjuntos

Todo sobre funciones

Funciones algebraicas lineales

Funciones algebraicas polinómicas

Funciones trascendentes

Funciones seccionadas

Funciones compuestas

¿Cómo manipular funciones?

Características de las Funciones Reales

Funciones en ciencia de datos

Conoce al perceptrón

Funciones de activación

Modela tu primer función

Entendiendo la regresión lineal simple

¿Cómo se calcula un error?

Este no es el fin

Te has iniciado detrás del secreto de la ciencia de datos