Aprendizaje automático: entrenar/probar
Evalúe su modelo
En Machine Learning creamos modelos para predecir el resultado de ciertos eventos, como en el capítulo anterior donde predijimos la emisión de CO2 de un automóvil cuando sabíamos el peso y el tamaño del motor.
Para medir si el modelo es lo suficientemente bueno, podemos usar un método llamado Train/Test.
¿Qué es Entrenar/Prueba?
Train/Test es un método para medir la precisión de su modelo.
Se llama Train/Test porque divide el conjunto de datos en dos conjuntos: un conjunto de entrenamiento y un conjunto de prueba.
80% para entrenamiento y 20% para pruebas.
El modelo se entrena con el conjunto de entrenamiento.
Usted prueba el modelo usando el conjunto de prueba.
Entrenar el modelo significa crear el modelo.
Probar el modelo significa probar la precisión del modelo.
Comience con un conjunto de datos
Comience con un conjunto de datos que desee probar.
Nuestro conjunto de datos ilustra 100 clientes en una tienda y sus hábitos de compra.
Ejemplo
import numpy
import matplotlib.pyplot as plt
numpy.random.seed(2)
x = numpy.random.normal(3, 1, 100)
y = numpy.random.normal(150, 40,
100) / x
plt.scatter(x, y)
plt.show()
Resultado:
El eje x representa la cantidad de minutos antes de realizar una compra.
El eje y representa la cantidad de dinero gastado en la compra.
Dividir en tren/prueba
El conjunto de entrenamiento debe ser una selección aleatoria del 80% de los datos originales.
El conjunto de prueba debe ser el 20% restante.
train_x = x[:80]
train_y = y[:80]
test_x = x[80:]
test_y = y[80:]
Mostrar el conjunto de entrenamiento
Muestre el mismo diagrama de dispersión con el conjunto de entrenamiento:
Ejemplo
plt.scatter(train_x,
train_y)
plt.show()
Resultado:
Parece el conjunto de datos original, por lo que parece ser una selección justa:
Mostrar el conjunto de prueba
Para asegurarnos de que el conjunto de prueba no sea completamente diferente, también echaremos un vistazo al conjunto de prueba.
Ejemplo
plt.scatter(test_x,
test_y)
plt.show()
Resultado:
El conjunto de prueba también se parece al conjunto de datos original:
Ajuste el conjunto de datos
¿Cómo se ve el conjunto de datos? En mi opinión, creo que el mejor ajuste sería una regresión polinomial , así que dibujemos una línea de regresión polinomial.
Para dibujar una línea a través de los puntos de datos, usamos el
plot()método del módulo matplotlib:
Ejemplo
Dibuja una línea de regresión polinomial a través de los puntos de datos:
import numpy
import
matplotlib.pyplot as plt
numpy.random.seed(2)
x =
numpy.random.normal(3, 1, 100)
y = numpy.random.normal(150, 40, 100) / x
train_x = x[:80]
train_y = y[:80]
test_x = x[80:]
test_y =
y[80:]
mymodel = numpy.poly1d(numpy.polyfit(train_x, train_y, 4))
myline = numpy.linspace(0, 6, 100)
plt.scatter(train_x, train_y)
plt.plot(myline, mymodel(myline))
plt.show()
Resultado:
El resultado puede respaldar mi sugerencia de que el conjunto de datos se ajusta a una regresión polinomial, aunque nos daría algunos resultados extraños si tratamos de predecir valores fuera del conjunto de datos. Ejemplo: la línea indica que un cliente que pasa 6 minutos en la tienda haría una compra por valor de 200. Eso probablemente sea un signo de sobreajuste.
Pero, ¿qué pasa con el puntaje R-cuadrado? El puntaje R-cuadrado es un buen indicador de qué tan bien mi conjunto de datos se ajusta al modelo.
R2
¿Recuerdas R2, también conocido como R-cuadrado?
Mide la relación entre el eje x y el eje y, y el valor varía de 0 a 1, donde 0 significa que no hay relación y 1 significa que está totalmente relacionado.
El módulo sklearn tiene un método llamado r2_score()
que nos ayudará a encontrar esta relación.
En este caso nos gustaría medir la relación entre los minutos que un cliente permanece en la tienda y cuánto dinero gasta.
Ejemplo
¿Qué tan bien encajan mis datos de entrenamiento en una regresión polinomial?
import numpy
from sklearn.metrics import r2_score
numpy.random.seed(2)
x = numpy.random.normal(3, 1, 100)
y = numpy.random.normal(150, 40,
100) / x
train_x = x[:80]
train_y = y[:80]
test_x = x[80:]
test_y = y[80:]
mymodel = numpy.poly1d(numpy.polyfit(train_x, train_y,
4))
r2 = r2_score(train_y, mymodel(train_x))
print(r2)
Nota: El resultado 0.799 muestra que existe una relación OK.
Traiga el conjunto de prueba
Ahora hemos creado un modelo que está bien, al menos cuando se trata de datos de entrenamiento.
Ahora también queremos probar el modelo con los datos de prueba, para ver si nos da el mismo resultado.
Ejemplo
Encontremos el puntaje R2 cuando usamos datos de prueba:
import numpy
from sklearn.metrics import r2_score
numpy.random.seed(2)
x = numpy.random.normal(3, 1, 100)
y = numpy.random.normal(150, 40,
100) / x
train_x = x[:80]
train_y = y[:80]
test_x = x[80:]
test_y = y[80:]
mymodel = numpy.poly1d(numpy.polyfit(train_x, train_y,
4))
r2 = r2_score(test_y, mymodel(test_x))
print(r2)
Nota: El resultado 0.809 muestra que el modelo también se ajusta al conjunto de prueba y estamos seguros de que podemos usar el modelo para predecir valores futuros.
Predecir valores
Ahora que hemos establecido que nuestro modelo está bien, podemos comenzar a predecir nuevos valores.
Ejemplo
¿Cuánto dinero gastará un cliente que compra, si permanece en la tienda durante 5 minutos?
print(mymodel(5))
El ejemplo predijo que el cliente gastaría 22,88 dólares, como parece corresponder al diagrama:
