Mezcla es un algoritmo de aprendizaje de máquina en conjunto.
Es un nombre coloquial para generalización apilada o conjunto de apilamiento donde en lugar de encajar el meta-modelo en las predicciones hechas por el modelo base, se encaja en las predicciones hechas en un conjunto de datos de reserva.
La mezcla se utilizó para describir modelos de apilamiento que combinaban muchos cientos de modelos de predicción de los competidores en la competición de aprendizaje de máquinas de Netflix de 1 millón de dólares y, como tal, sigue siendo una técnica y un nombre popular para el apilamiento en los círculos de aprendizaje de máquinas de la competencia, como la comunidad Kaggle.
En este tutorial, descubrirá cómo desarrollar y evaluar un conjunto de mezcla en pitón.
Después de completar este tutorial, lo sabrás:
- Los conjuntos mixtos son un tipo de apilamiento en el que el metomodelo se ajusta utilizando predicciones sobre un conjunto de datos de validación de la retención en lugar de predicciones fuera de la retención.
- Cómo desarrollar un conjunto de mezclas, incluyendo funciones para entrenar el modelo y hacer predicciones sobre nuevos datos.
- Cómo evaluar los conjuntos de mezclas para la clasificación y la regresión de los problemas de modelado predictivo.
Empecemos.
Mezclando el aprendizaje de la máquina con la pitón
Foto de Nathalie, algunos derechos reservados.
Resumen del Tutorial
Este tutorial está dividido en cuatro partes; son:
- Conjunto de mezcla
- Desarrollar un conjunto de mezcla
- Conjunto de mezcla para la clasificación
- Conjunto de mezcla para la regresión
Conjunto de mezcla
La mezcla es una técnica de aprendizaje de máquinas de conjunto que utiliza un modelo de aprendizaje de máquinas para aprender a combinar de la mejor manera posible las predicciones de los múltiples modelos de miembros de un conjunto que contribuyen.
Como tal, la mezcla es lo mismo que la generalización apilada, conocida como apilamiento, concebida en términos generales. A menudo, la mezcla y el apilamiento se utilizan indistintamente en el mismo papel o en la descripción del modelo.
Muchos practicantes de aprendizaje de máquinas han tenido éxito utilizando el apilamiento y técnicas conexas para aumentar la precisión de las predicciones más allá del nivel obtenido por cualquiera de los modelos individuales. En algunos contextos, el apilamiento también se conoce como mezcla, y aquí usaremos los términos indistintamente.
– Apilamiento Lineal Ponderado, 2009.
La arquitectura de un modelo de apilamiento implica dos o más modelos base, a menudo denominados modelos de nivel 0, y un meta-modelo que combina las predicciones de los modelos base, denominado modelo de nivel 1. El meta-modelo se entrena en las predicciones hechas por los modelos base sobre datos fuera de muestra.
- Modelos de nivel 0 (Modelos de base): Los modelos se ajustan a los datos de entrenamiento y cuyas predicciones se compilan.
- Modelo de nivel 1 (Meta-Modelo): Modelo que aprende a combinar mejor las predicciones de los modelos base.
Sin embargo, la mezcla tiene connotaciones específicas sobre cómo construir un modelo de conjunto apilado.
La mezcla puede sugerir el desarrollo de un conjunto de apilamiento en el que los modelos base son modelos de aprendizaje de máquinas de cualquier tipo, y el meta-modelo es un modelo lineal que «mezclas» las predicciones de los modelos base.
Por ejemplo, un modelo de regresión lineal cuando se predice un valor numérico o un modelo de regresión logística cuando se predice una etiqueta de clase, calcularía una suma ponderada de las predicciones hechas por los modelos de base y se consideraría una mezcla de predicciones.
- Conjunto de mezcla: Uso de un modelo lineal, como la regresión lineal o la regresión logística, como el meta-modelo en un conjunto de apilamiento.
Mezcla fue el término comúnmente usado para apilar conjuntos durante el premio Netflix en 2009. El premio consistía en que los equipos buscaran predicciones de recomendación de películas que se desempeñaran mejor que el algoritmo nativo de Netflix y se otorgó un premio de 1 millón de dólares al equipo que lograra una mejora del rendimiento del 10 por ciento.
Nuestra solución RMSE=0.8643^2 es una mezcla lineal de más de 100 resultados. […] A lo largo de la descripción de los métodos, destacamos los predictores específicos que participaron en la solución mixta final.
– La solución de BellKor 2008 para el premio Netflix, 2008.
Como tal, la mezcla es un término coloquial para el aprendizaje en conjunto con un modelo de arquitectura de tipo apilamiento. Rara vez, si es que alguna vez, se utiliza en libros de texto o documentos académicos, aparte de los relacionados con el aprendizaje de máquinas competitivas.
Lo más común es que la mezcla se utilice para describir la aplicación específica del apilamiento en la que el meta-modelo se entrena en las predicciones hechas por los modelos de base en un conjunto de datos de validación de apilamiento. En este contexto, el apilamiento se reserva para un meta-modelo que se entrena en las predicciones fuera de pliegue durante un procedimiento de validación cruzada.
- Mezcla: Conjunto de tipo apilable donde el meta-modelo se entrena en predicciones hechas en un conjunto de datos de reserva.
- Apilamiento: Conjunto de tipo apilable donde el meta-modelo se entrena en las predicciones fuera de pliegue hechas durante la validación cruzada de pliegue k.
Esta distinción es común entre la comunidad de aprendizaje de la máquina competitiva Kaggle.
Mezcla es una palabra introducida por los ganadores de Netflix. Está muy cerca de la generalización apilada, pero es un poco más simple y con menos riesgo de fuga de información. […] Con la mezcla, en lugar de crear predicciones fuera de lugar para el tren, se crea un pequeño conjunto de reserva de, digamos, el 10% del tren. El modelo de apilador entonces se entrena sólo en este conjunto de reserva.
– Guía del Conjunto Kaggle, MLWave, 2015.
Utilizaremos esta última definición de mezcla.
A continuación, veamos cómo podemos implementar la mezcla.
Desarrollar un conjunto de mezcla
La biblioteca de aprendizaje de ciencias no apoya de forma nativa la mezcla en el momento de escribir este artículo.
En cambio, podemos implementarlo nosotros mismos usando modelos de aprendizaje científico.
Primero, necesitamos crear un número de modelos base. Estos pueden ser los modelos que queramos para un problema de regresión o clasificación. Podemos definir una función get_models() que devuelve una lista de modelos donde cada modelo se define como una tupla con un nombre y el clasificador u objeto de regresión configurado.
Por ejemplo, para un problema de clasificación, podríamos usar una regresión logística, kNN, árbol de decisión, SVM, y el modelo de Bayes ingenuo.
|
# Obtener una lista de modelos base def get_models(): modelos = lista() modelos.anexar((«lr, LogisticRegression())) modelos.anexar((«knn, KNeighborsClassifier())) modelos.anexar((«carro, DecisionTreeClassifier())) modelos.anexar((«svm, SVC(probabilidad=Verdadero))) modelos.anexar((«bayes, GaussianNB())) volver modelos |
A continuación, tenemos que ajustar el modelo de mezcla.
Recuerde que los modelos de base se ajustan a un conjunto de datos de entrenamiento. El meta-modelo se ajusta a las predicciones hechas por cada modelo base en un conjunto de datos de retención.
En primer lugar, podemos enumerar la lista de modelos y ajustar cada uno a su vez en el conjunto de datos de entrenamiento. También en este bucle, podemos usar el modelo de ajuste para hacer una predicción en el conjunto de datos de retención (validación) y almacenar las predicciones para más tarde.
|
... # Encajar todos los modelos en el set de entrenamiento y predecir en el set de espera meta_X = lista() para nombre, modelo en modelos: # Encajar en el set de entrenamiento modelo.encajar(X_tren, y_tren) # Predecir en el set de espera yhat = modelo.predecir(X_val) # remodelar las predicciones en una matriz con una columna yhat = yhat.remodelar(len(yhat), 1) # Almacenar las predicciones como entrada para la mezcla meta_X.anexar(yhat) |
Ahora tenemos…meta_X«que representa los datos de entrada que pueden ser usados para entrenar el meta-modelo. Cada columna o característica representa la salida de un modelo base.
Cada fila representa una muestra del conjunto de datos de la reserva. Podemos usar la función hstack() para asegurarnos de que este conjunto de datos es una matriz numérica 2D como se espera de un modelo de aprendizaje automático.
|
... # Crear una matriz 2d a partir de las predicciones, cada conjunto es una característica de entrada meta_X = hstack(meta_X) |
Ahora podemos entrenar nuestro meta-modelo. Puede ser cualquier modelo de aprendizaje de máquinas que queramos, como la regresión logística para la clasificación.
|
... # Definir el modelo de mezcla licuadora = LogisticRegression() # Encajar en las predicciones de los modelos de base licuadora.encajar(meta_X, y_val) |
Podemos unir todo esto en una función llamada fit_ensemble() que entrena el modelo de mezcla usando un conjunto de datos de entrenamiento y un conjunto de datos de validación de retención.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
# Encaja en el conjunto de la mezcla def fit_ensemble(modelos, X_tren, X_val, y_tren, y_val): # Encajar todos los modelos en el set de entrenamiento y predecir en el set de espera meta_X = lista() para nombre, modelo en modelos: # Encajar en el set de entrenamiento modelo.encajar(X_tren, y_tren) # Predecir en el set de espera yhat = modelo.predecir(X_val) # remodelar las predicciones en una matriz con una columna yhat = yhat.remodelar(len(yhat), 1) # Almacenar las predicciones como entrada para la mezcla meta_X.anexar(yhat) # Crear una matriz 2d a partir de las predicciones, cada conjunto es una característica de entrada meta_X = hstack(meta_X) # Definir el modelo de mezcla licuadora = LogisticRegression() # Encajar en las predicciones de los modelos de base licuadora.encajar(meta_X, y_val) volver licuadora |
El siguiente paso es usar el conjunto de mezcla para hacer predicciones sobre nuevos datos.
Este es un proceso de dos pasos. El primer paso es usar cada modelo base para hacer una predicción. Estas predicciones son luego reunidas y usadas como insumo para el modelo de mezcla para hacer la predicción final.
Podemos usar la misma estructura de bucle que usamos cuando entrenamos el modelo. Es decir, podemos recoger las predicciones de cada modelo base en un conjunto de datos de entrenamiento, apilar las predicciones y llamar a predecir() en el modelo de la licuadora con este conjunto de datos de meta-nivel.
El predict_ensemble() La función de abajo implementa esto. Dada la lista de modelos de base de ajuste, el conjunto de mezcladores de ajuste y un conjunto de datos (como un conjunto de datos de prueba o nuevos datos), devolverá un conjunto de predicciones para el conjunto de datos.
|
# Hacer una predicción con el conjunto de la mezcla def predict_ensemble(modelos, licuadora, X_test): # Hacer predicciones con modelos de base meta_X = lista() para nombre, modelo en modelos: # predecir con el modelo base yhat = modelo.predecir(X_test) # remodelar las predicciones en una matriz con una columna yhat = yhat.remodelar(len(yhat), 1) # Predicción de la tienda meta_X.anexar(yhat) # Crear una matriz 2d a partir de las predicciones, cada conjunto es una característica de entrada meta_X = hstack(meta_X) # Predecir volver licuadora.predecir(meta_X) |
Ahora tenemos todos los elementos necesarios para implementar un conjunto de mezcla para la clasificación o los problemas de modelado predictivo de regresión
Conjunto de mezcla para la clasificación
En esta sección, veremos el uso de la mezcla para un problema de clasificación.
Primero, podemos usar la función make_classification() para crear un problema de clasificación binaria sintética con 10.000 ejemplos y 20 características de entrada.
El ejemplo completo figura a continuación.
|
# Conjunto de datos de clasificación de pruebas de sklearn.conjuntos de datos importación hacer_clasificación # Definir el conjunto de datos X, y = make_classification(n_muestras=10000, n_funciones=20, n_informativo=15, n_redundante=5, estado_aleatorio=7) # resumir el conjunto de datos imprimir(X.forma, y.forma) |
Ejecutando el ejemplo se crea el conjunto de datos y se resume la forma de los componentes de entrada y salida.
A continuación, necesitamos dividir el conjunto de datos, primero en conjuntos de entrenamiento y pruebas, y luego el conjunto de entrenamiento en un subconjunto utilizado para entrenar los modelos base y un subconjunto utilizado para entrenar el meta-modelo.
En este caso, usaremos una división 50-50 para el tren y los juegos de prueba, y luego usaremos una división 67-33 para el tren y los juegos de validación.
|
... # Dividir el conjunto de datos en trenes y conjuntos de pruebas X_tren_completo, X_test, y_entrenamiento_completo, y_test = prueba_de_trenes_split(X, y, tamaño_de_prueba=0.5, estado_aleatorio=1) # Dividir el conjunto de entrenamiento en conjuntos de entrenamiento y validación X_tren, X_val, y_tren, y_val = prueba_de_trenes_split(X_tren_completo, y_entrenamiento_completo, tamaño_de_prueba=0.33, estado_aleatorio=1) # Integrar la división de los datos imprimir(«Tren: %s, Val: %s, Prueba: %s % (X_tren.forma, X_val.forma, X_test.forma)) |
Entonces podemos usar el get_models() de la sección anterior para crear los modelos de clasificación utilizados en el conjunto.
El fit_ensemble() se puede llamar a la función para ajustar el conjunto de mezcla en el tren y los conjuntos de datos de validación y el predict_ensemble() puede utilizarse para hacer predicciones sobre el conjunto de datos de la retención.
|
... # Crear los modelos base modelos = get_models() # entrenar el conjunto de mezcla licuadora = fit_ensemble(modelos, X_tren, X_val, y_tren, y_val) # Hacer predicciones en el equipo de pruebas yhat = predict_ensemble(modelos, licuadora, X_test) |
Por último, podemos evaluar el rendimiento del modelo de mezcla informando de la precisión de la clasificación en el conjunto de datos de la prueba.
|
... # Evaluar las predicciones puntuación = accuracy_score(y_test, yhat) imprimir(Precisión de la mezcla: %.3f’. % puntuación) |
Enlazando todo esto, el ejemplo completo de la evaluación de un conjunto de mezclas sobre el problema de la clasificación binaria sintética se enumera a continuación.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 |
# Mezclando el conjunto para la clasificación usando la votación dura de numpy importación hstack de sklearn.conjuntos de datos importación make_classification de sklearn.model_selection importación prueba_de_trenes_split de sklearn.métrica importación accuracy_score de sklearn.modelo_lineal importación LogisticRegression de sklearn.vecinos importación KNeighborsClassifier de sklearn.árbol importación DecisionTreeClassifier de sklearn.svm importación SVC de sklearn.naive_bayes importación GaussianNB # Obtener el conjunto de datos def get_dataset(): X, y = make_classification(n_muestras=10000, n_funciones=20, n_informativo=15, n_redundante=5, estado_aleatorio=7) volver X, y # Obtener una lista de modelos base def get_models(): modelos = lista() modelos.anexar((«lr, LogisticRegression())) modelos.anexar((«knn, KNeighborsClassifier())) modelos.anexar((«carro, DecisionTreeClassifier())) modelos.anexar((«svm, SVC())) modelos.anexar((«bayes, GaussianNB())) volver modelos # Encaja en el conjunto de la mezcla def fit_ensemble(modelos, X_tren, X_val, y_tren, y_val): # Encajar todos los modelos en el set de entrenamiento y predecir en el set de espera meta_X = lista() para nombre, modelo en modelos: # Encajar en el set de entrenamiento modelo.encajar(X_tren, y_tren) # Predecir en el set de espera yhat = modelo.predecir(X_val) # remodelar las predicciones en una matriz con una columna yhat = yhat.remodelar(len(yhat), 1) # Almacenar las predicciones como entrada para la mezcla meta_X.anexar(yhat) # Crear una matriz 2d a partir de las predicciones, cada conjunto es una característica de entrada meta_X = hstack(meta_X) # Definir el modelo de mezcla licuadora = LogisticRegression() # Encajar en las predicciones de los modelos de base licuadora.encajar(meta_X, y_val) volver licuadora # Hacer una predicción con el conjunto de la mezcla def predict_ensemble(modelos, licuadora, X_test): # Hacer predicciones con modelos de base meta_X = lista() para nombre, modelo en modelos: # predecir con el modelo base yhat = modelo.predecir(X_test) # remodelar las predicciones en una matriz con una columna yhat = yhat.remodelar(len(yhat), 1) # Predicción de la tienda meta_X.anexar(yhat) # Crear una matriz 2d a partir de las predicciones, cada conjunto es una característica de entrada meta_X = hstack(meta_X) # Predecir volver licuadora.predecir(meta_X) # Definir el conjunto de datos X, y = get_dataset() # Dividir el conjunto de datos en trenes y conjuntos de pruebas X_tren_completo, X_test, y_entrenamiento_completo, y_test = prueba_de_trenes_split(X, y, tamaño_de_prueba=0.5, estado_aleatorio=1) # Dividir el conjunto de entrenamiento en conjuntos de entrenamiento y validación X_tren, X_val, y_tren, y_val = prueba_de_trenes_split(X_tren_completo, y_entrenamiento_completo, tamaño_de_prueba=0.33, estado_aleatorio=1) # Integrar la división de los datos imprimir(«Tren: %s, Val: %s, Prueba: %s % (X_tren.forma, X_val.forma, X_test.forma)) # Crear los modelos base modelos = get_models() # entrenar el conjunto de mezcla licuadora = fit_ensemble(modelos, X_tren, X_val, y_tren, y_val) # Hacer predicciones en el equipo de pruebas yhat = predict_ensemble(modelos, licuadora, X_test) # Evaluar las predicciones puntuación = accuracy_score(y_test, yhat) imprimir(Precisión de la mezcla: %.3f’. % (puntuación*100)) |
La ejecución del ejemplo reporta primero la forma del tren, la validación y los conjuntos de datos de prueba, luego la precisión del conjunto en el conjunto de datos de prueba.
Nota: Sus resultados pueden variar dada la naturaleza estocástica del algoritmo o el procedimiento de evaluación, o las diferencias en la precisión numérica. Considere ejecutar el ejemplo unas cuantas veces y compare el resultado promedio.
En este caso, podemos ver que el conjunto de la mezcla alcanzó una precisión de clasificación de alrededor del 97.900 por ciento.
|
Tren: (3350, 20), Val: (1650, 20), Prueba: (5000, 20) Precisión de la mezcla: 97.900 |
En el ejemplo anterior, las predicciones de las etiquetas de clase se combinaron utilizando el modelo de mezcla. Este es un tipo de votación difícil.
Una alternativa es hacer que cada modelo prediga las probabilidades de clase y usar el meta-modelo para mezclar las probabilidades. Este es un tipo de votación suave y puede resultar en un mejor rendimiento en algunos casos.
Primero, debemos configurar los modelos para devolver probabilidades, como el modelo SVM.
|
# Obtener una lista de modelos base def get_models(): modelos = lista() modelos.anexar((«lr, LogisticRegression())) modelos.anexar((«knn, KNeighborsClassifier())) modelos.anexar((«carro, DecisionTreeClassifier())) modelos.anexar((«svm, SVC(probabilidad=Verdadero))) modelos.anexar((«bayes, GaussianNB())) volver modelos |
A continuación, debemos cambiar los modelos base para predecir probabilidades en lugar de etiquetas de clase nítidas.
Esto puede lograrse llamando al predict_proba() función en el fit_ensemble() cuando se ajusta a los modelos de base.
|
... # Encajar todos los modelos en el set de entrenamiento y predecir en el set de espera meta_X = lista() para nombre, modelo en modelos: # Encajar en el set de entrenamiento modelo.encajar(X_tren, y_tren) # Predecir en el set de espera yhat = modelo.predict_proba(X_val) # Almacenar las predicciones como entrada para la mezcla meta_X.anexar(yhat) |
Esto significa que el conjunto de metadatos utilizado para entrenar el metomodelo tendrá n columnas por clasificador, donde n es el número de clases en el problema de predicción, dos en nuestro caso.
También tenemos que cambiar las predicciones hechas por los modelos base cuando se utiliza el modelo de mezcla para hacer predicciones sobre nuevos datos.
|
... # Hacer predicciones con modelos de base meta_X = lista() para nombre, modelo en modelos: # predecir con el modelo base yhat = modelo.predict_proba(X_test) # Predicción de la tienda meta_X.anexar(yhat) |
A continuación se enumera el ejemplo completo de la utilización de la combinación de probabilidades de clase previstas para el problema de la clasificación binaria sintética.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 |
# Mezclando el conjunto para la clasificación usando la votación suave de numpy importación hstack de sklearn.conjuntos de datos importación make_classification de sklearn.model_selection importación prueba_de_trenes_split de sklearn.métrica importación accuracy_score de sklearn.modelo_lineal importación LogisticRegression de sklearn.vecinos importación KNeighborsClassifier de sklearn.árbol importación DecisionTreeClassifier de sklearn.svm importación SVC de sklearn.naive_bayes importación GaussianNB # Obtener el conjunto de datos def get_dataset(): X, y = make_classification(n_muestras=10000, n_funciones=20, n_informativo=15, n_redundante=5, estado_aleatorio=7) volver X, y # Obtener una lista de modelos base def get_models(): modelos = lista() modelos.anexar((«lr, LogisticRegression())) modelos.anexar((«knn, KNeighborsClassifier())) modelos.anexar((«carro, DecisionTreeClassifier())) modelos.anexar((«svm, SVC(probabilidad=Verdadero))) modelos.anexar((«bayes, GaussianNB())) volver modelos # Encaja en el conjunto de la mezcla def fit_ensemble(modelos, X_tren, X_val, y_tren, y_val): # Encajar todos los modelos en el set de entrenamiento y predecir en el set de espera meta_X = lista() para nombre, modelo en modelos: # Encajar en el set de entrenamiento modelo.encajar(X_tren, y_tren) # Predecir en el set de espera yhat = modelo.predict_proba(X_val) # Almacenar las predicciones como entrada para la mezcla meta_X.anexar(yhat) # Crear una matriz 2d a partir de las predicciones, cada conjunto es una característica de entrada meta_X = hstack(meta_X) # Definir el modelo de mezcla licuadora = LogisticRegression() # Encajar en las predicciones de los modelos de base licuadora.encajar(meta_X, y_val) volver licuadora # Hacer una predicción con el conjunto de la mezcla def predict_ensemble(modelos, licuadora, X_test): # Hacer predicciones con modelos de base meta_X = lista() para nombre, modelo en modelos: # predecir con el modelo base yhat = modelo.predict_proba(X_test) # Predicción de la tienda meta_X.anexar(yhat) # Crear una matriz 2d a partir de las predicciones, cada conjunto es una característica de entrada meta_X = hstack(meta_X) # Predecir volver licuadora.predecir(meta_X) # Definir el conjunto de datos X, y = get_dataset() # Dividir el conjunto de datos en trenes y conjuntos de pruebas X_tren_completo, X_test, y_entrenamiento_completo, y_test = prueba_de_trenes_split(X, y, tamaño_de_prueba=0.5, estado_aleatorio=1) # Dividir el conjunto de entrenamiento en conjuntos de entrenamiento y validación X_tren, X_val, y_tren, y_val = prueba_de_trenes_split(X_tren_completo, y_entrenamiento_completo, tamaño_de_prueba=0.33, estado_aleatorio=1) # Integrar la división de los datos imprimir(«Tren: %s, Val: %s, Prueba: %s % (X_tren.forma, X_val.forma, X_test.forma)) # Crear los modelos base modelos = get_models() # entrenar el conjunto de mezcla licuadora = fit_ensemble(modelos, X_tren, X_val, y_tren, y_val) # Hacer predicciones en el equipo de pruebas yhat = predict_ensemble(modelos, licuadora, X_test) # Evaluar las predicciones puntuación = accuracy_score(y_test, yhat) imprimir(Precisión de la mezcla: %.3f’. % (puntuación*100)) |
La ejecución del ejemplo reporta primero la forma del tren, la validación y los conjuntos de datos de prueba, luego la precisión del conjunto en el conjunto de datos de prueba.
Nota: Sus resultados pueden variar dada la naturaleza estocástica del algoritmo o el procedimiento de evaluación, o las diferencias en la precisión numérica. Considere ejecutar el ejemplo unas cuantas veces y compare el resultado promedio.
En este caso, podemos ver que la mezcla de las probabilidades de clase resultó en un aumento de la precisión de la clasificación a cerca del 98,240 por ciento.
|
Tren: (3350, 20), Val: (1650, 20), Prueba: (5000, 20) Precisión de la mezcla: 98.240 |
Un conjunto de mezcla sólo es efectivo si es capaz de superar a cualquier modelo que contribuya.
Podemos confirmarlo evaluando cada uno de los modelos base de forma aislada. Cada modelo base puede encajar en todo el conjunto de datos de entrenamiento (a diferencia del conjunto de mezcla) y ser evaluado en el conjunto de datos de prueba (al igual que el conjunto de mezcla).
El ejemplo que se presenta a continuación lo demuestra, evaluando cada modelo base de forma aislada.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 |
# Evaluar los modelos de base en todo el conjunto de datos de entrenamiento de sklearn.conjuntos de datos importación make_classification de sklearn.model_selection importación prueba_de_trenes_split de sklearn.métrica importación accuracy_score de sklearn.modelo_lineal importación LogisticRegression de sklearn.vecinos importación KNeighborsClassifier de sklearn.árbol importación DecisionTreeClassifier de sklearn.svm importación SVC de sklearn.naive_bayes importación GaussianNB # Obtener el conjunto de datos def get_dataset(): X, y = make_classification(n_muestras=10000, n_funciones=20, n_informativo=15, n_redundante=5, estado_aleatorio=7) volver X, y # Obtener una lista de modelos base def get_models(): modelos = lista() modelos.anexar((«lr, LogisticRegression())) modelos.anexar((«knn, KNeighborsClassifier())) modelos.anexar((«carro, DecisionTreeClassifier())) modelos.anexar((«svm, SVC(probabilidad=Verdadero))) modelos.anexar((«bayes, GaussianNB())) volver modelos # Definir el conjunto de datos X, y = get_dataset() # Dividir el conjunto de datos en trenes y conjuntos de pruebas X_tren_completo, X_test, y_entrenamiento_completo, y_test = prueba_de_trenes_split(X, y, tamaño_de_prueba=0.5, estado_aleatorio=1) # Integrar la división de los datos imprimir(«Tren: %s, Prueba: %s % (X_tren_completo.forma, X_test.forma)) # Crear los modelos base modelos = get_models() # Evaluar el modelo independiente para nombre, modelo en modelos: # Encajar el modelo en el conjunto de datos de entrenamiento modelo.encajar(X_tren_completo, y_entrenamiento_completo) # Hacer una predicción en el conjunto de datos de la prueba yhat = modelo.predecir(X_test) # Evaluar las predicciones puntuación = accuracy_score(y_test, yhat) # Reportar el resultado… imprimir(Precisión: %.3f’. % (nombre, puntuación*100)) |
La ejecución del ejemplo reporta primero la forma del tren completo y los conjuntos de datos de prueba, luego la precisión de cada modelo base en el conjunto de datos de prueba.
Nota: Sus resultados pueden variar dada la naturaleza estocástica del algoritmo o el procedimiento de evaluación, o las diferencias en la precisión numérica. Considere ejecutar el ejemplo unas cuantas veces y compare el resultado promedio.
En este caso, podemos ver que todos los modelos se desempeñan peor que el conjunto mixto.
Curiosamente, podemos ver que el SVM se acerca mucho a lograr una precisión del 98,200 por ciento en comparación con el 98,240 logrado con el conjunto de mezcla.
|
Tren: (5000, 20), Prueba: (5000, 20) >lr Precisión: 87.800 >knn Precisión: 97.380 >Precisión del carro: 88.200 >svm Precisión: 98.200 >bayes Precisión: 87.300 |
Podemos elegir usar un conjunto de mezcla como nuestro modelo final.
Esto implica encajar el conjunto en el conjunto de datos de entrenamiento completo y hacer predicciones sobre nuevos ejemplos. Específicamente, todo el conjunto de datos de entrenamiento se divide en conjuntos de entrenamiento y validación para entrenar la base y los meta-modelos respectivamente, entonces el conjunto puede ser usado para hacer una predicción.
El ejemplo completo de hacer una predicción sobre nuevos datos con un conjunto de mezcla para su clasificación se enumera a continuación.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 |
# ejemplo de hacer una predicción con un conjunto de mezcla para la clasificación de numpy importación hstack de sklearn.conjuntos de datos importación make_classification de sklearn.model_selection importación prueba_de_trenes_split de sklearn.modelo_lineal importación LogisticRegression de sklearn.vecinos importación KNeighborsClassifier de sklearn.árbol importación DecisionTreeClassifier de sklearn.svm importación SVC de sklearn.naive_bayes importación GaussianNB # Obtener el conjunto de datos def get_dataset(): X, y = make_classification(n_muestras=10000, n_funciones=20, n_informativo=15, n_redundante=5, estado_aleatorio=7) volver X, y # Obtener una lista de modelos base def get_models(): modelos = lista() modelos.anexar((«lr, LogisticRegression())) modelos.anexar((«knn, KNeighborsClassifier())) modelos.anexar((«carro, DecisionTreeClassifier())) modelos.anexar((«svm, SVC(probabilidad=Verdadero))) modelos.anexar((«bayes, GaussianNB())) volver modelos # Encaja en el conjunto de la mezcla def fit_ensemble(modelos, X_tren, X_val, y_tren, y_val): # Encajar todos los modelos en el set de entrenamiento y predecir en el set de espera meta_X = lista() para _, modelo en modelos: # Encajar en el set de entrenamiento modelo.encajar(X_tren, y_tren) # Predecir en el set de espera yhat = modelo.predict_proba(X_val) # Almacenar las predicciones como entrada para la mezcla meta_X.anexar(yhat) # Crear una matriz 2d a partir de las predicciones, cada conjunto es una característica de entrada meta_X = hstack(meta_X) # Definir el modelo de mezcla licuadora = LogisticRegression() # Encajar en las predicciones de los modelos de base licuadora.encajar(meta_X, y_val) volver licuadora # Hacer una predicción con el conjunto de la mezcla def predict_ensemble(modelos, licuadora, X_test): # Hacer predicciones con modelos de base meta_X = lista() para _, modelo en modelos: # predecir con el modelo base yhat = modelo.predict_proba(X_test) # Predicción de la tienda meta_X.anexar(yhat) # Crear una matriz 2d a partir de las predicciones, cada conjunto es una característica de entrada meta_X = hstack(meta_X) # Predecir volver licuadora.predecir(meta_X) # Definir el conjunto de datos X, y = get_dataset() # Dividir el conjunto de datos en conjuntos de tren y validación X_tren, X_val, y_tren, y_val = prueba_de_trenes_split(X, y, tamaño_de_prueba=0.33, estado_aleatorio=1) # Integrar la división de los datos imprimir(«Tren: %s, Val: %s % (X_tren.forma, X_val.forma)) # Crear los modelos base modelos = get_models() # entrenar el conjunto de mezcla licuadora = fit_ensemble(modelos, X_tren, X_val, y_tren, y_val) # hacer una predicción en una nueva fila de datos fila = [[–0.30335011, 2.68066314, 2.07794281, 1.15253537, –2.0583897, –2.51936601, 0.67513028, –3.20651939, –1.60345385, 3.68820714, 0.05370913, 1.35804433, 0.42011397, 1.4732839, 2.89997622, 1.61119399, 7.72630965, –2.84089477, –1.83977415, 1.34381989] yhat = predict_ensemble(modelos, licuadora, [[fila]) # resumir la predicción imprimir(Clase prevista: %d’. % (yhat)) |
La ejecución del ejemplo encaja con el modelo de conjunto de mezcla en el conjunto de datos y luego se utiliza para hacer una predicción sobre una nueva fila de datos, como podríamos hacer al utilizar el modelo en una aplicación.
|
Tren: (6700, 20), Val: (3300, 20) Clase Prevista: 1 |
A continuación, vamos a explorar cómo podríamos evaluar un conjunto de mezcla para la regresión.
Conjunto de mezcla para la regresión
En esta sección, veremos el uso del apilamiento para un problema de regresión.
Primero, podemos usar la función make_regression() para crear un problema de regresión sintética con 10.000 ejemplos y 20 características de entrada.
El ejemplo completo figura a continuación.
|
# conjunto de datos de regresión de pruebas de sklearn.conjuntos de datos importación hacer_regresión # Definir el conjunto de datos X, y = make_regression(n_muestras=10000, n_funciones=20, n_informativo=10, ruido=0.3, estado_aleatorio=7) # resumir el conjunto de datos imprimir(X.forma, y.forma) |
Ejecutando el ejemplo se crea el conjunto de datos y se resume la forma de los componentes de entrada y salida.
A continuación, podemos definir la lista de modelos de regresión para usar como modelos base. En este caso, utilizaremos la regresión lineal, kNN, el árbol de decisión y los modelos SVM.
|
# Obtener una lista de modelos base def get_models(): modelos = lista() modelos.anexar((«lr, LinearRegression())) modelos.anexar((«knn, KNeighborsRegressor())) modelos.anexar((«carro, DecisionTreeRegressor())) modelos.anexar((«svm, SVR())) volver modelos |
El fit_ensemble() La función utilizada para entrenar el conjunto de la mezcla no cambia de la clasificación, aparte de que el modelo utilizado para la mezcla debe cambiarse a un modelo de regresión.
Usaremos el modelo de regresión lineal en este caso.
|
... # Definir el modelo de mezcla licuadora = LinearRegression() |
Dado que se trata de un problema de regresión, evaluaremos el rendimiento del modelo utilizando una métrica de error, en este caso, el error absoluto medio, o MAE para abreviar.
|
... # Evaluar las predicciones puntuación = error_absoluto_medio(y_test, yhat) imprimir(‘Mezcla MAE: %.3f’ % puntuación) |
A continuación se enumera el ejemplo completo de un conjunto de mezclas para el problema de modelado predictivo de regresión sintética.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 |
# Evaluar el conjunto de la mezcla para la regresión de numpy importación hstack de sklearn.conjuntos de datos importación make_regression de sklearn.model_selection importación prueba_de_trenes_split de sklearn.métrica importación error_absoluto_medio de sklearn.modelo_lineal importación LinearRegression de sklearn.vecinos importación KNeighborsRegressor de sklearn.árbol importación DecisionTreeRegressor de sklearn.svm importación SVR # Obtener el conjunto de datos def get_dataset(): X, y = make_regression(n_muestras=10000, n_funciones=20, n_informativo=10, ruido=0.3, estado_aleatorio=7) volver X, y # Obtener una lista de modelos base def get_models(): modelos = lista() modelos.anexar((«lr, LinearRegression())) modelos.anexar((«knn, KNeighborsRegressor())) modelos.anexar((«carro, DecisionTreeRegressor())) modelos.anexar((«svm, SVR())) volver modelos # Encaja en el conjunto de la mezcla def fit_ensemble(modelos, X_tren, X_val, y_tren, y_val): # Encajar todos los modelos en el set de entrenamiento y predecir en el set de espera meta_X = lista() para nombre, modelo en modelos: # Encajar en el set de entrenamiento modelo.encajar(X_tren, y_tren) # Predecir en el set de espera yhat = modelo.predecir(X_val) # remodelar las predicciones en una matriz con una columna yhat = yhat.remodelar(len(yhat), 1) # Almacenar las predicciones como entrada para la mezcla meta_X.anexar(yhat) # Crear una matriz 2d a partir de las predicciones, cada conjunto es una característica de entrada meta_X = hstack(meta_X) # Definir el modelo de mezcla licuadora = LinearRegression() # Encajar en las predicciones de los modelos de base licuadora.encajar(meta_X, y_val) volver licuadora # Hacer una predicción con el conjunto de la mezcla def predict_ensemble(modelos, licuadora, X_test): # Hacer predicciones con modelos de base meta_X = lista() para nombre, modelo en modelos: # predecir con el modelo base yhat = modelo.predecir(X_test) # remodelar las predicciones en una matriz con una columna yhat = yhat.remodelar(len(yhat), 1) # Predicción de la tienda meta_X.anexar(yhat) # Crear una matriz 2d a partir de las predicciones, cada conjunto es una característica de entrada meta_X = hstack(meta_X) # Predecir volver licuadora.predecir(meta_X) # Definir el conjunto de datos X, y = get_dataset() # Dividir el conjunto de datos en trenes y conjuntos de pruebas X_tren_completo, X_test, y_entrenamiento_completo, y_test = prueba_de_trenes_split(X, y, tamaño_de_prueba=0.5, estado_aleatorio=1) # Dividir el conjunto de entrenamiento en conjuntos de entrenamiento y validación X_tren, X_val, y_tren, y_val = prueba_de_trenes_split(X_tren_completo, y_entrenamiento_completo, tamaño_de_prueba=0.33, estado_aleatorio=1) # Integrar la división de los datos imprimir(«Tren: %s, Val: %s, Prueba: %s % (X_tren.forma, X_val.forma, X_test.forma)) # Crear los modelos base modelos = get_models() # entrenar el conjunto de mezcla licuadora = fit_ensemble(modelos, X_tren, X_val, y_tren, y_val) # Hacer predicciones en el equipo de pruebas yhat = predict_ensemble(modelos, licuadora, X_test) # Evaluar las predicciones puntuación = error_absoluto_medio(y_test, yhat) imprimir(‘Mezcla MAE: %.3f’ % puntuación) |
Ejecutando el ejemplo primero se informa de la forma del tren, la validación y los conjuntos de datos de prueba, luego el MAE del conjunto en el conjunto de datos de prueba.
Nota: Sus resultados pueden variar dada la naturaleza estocástica del algoritmo o el procedimiento de evaluación, o las diferencias en la precisión numérica. Considere ejecutar el ejemplo unas cuantas veces y compare el resultado promedio.
En este caso, podemos ver que el conjunto de mezcla alcanzó un MAE de alrededor de 0,237 en el conjunto de datos de la prueba.
|
Tren: (3350, 20), Val: (1650, 20), Prueba: (5000, 20) Mezcla MAE: 0.237 |
Al igual que con la clasificación, el conjunto de mezcla sólo es útil si se desempeña mejor que cualquiera de los modelos base que contribuyen al conjunto.
Podemos comprobarlo evaluando cada modelo base de forma aislada, ajustándolo primero al conjunto de datos de entrenamiento (a diferencia del conjunto de mezcla) y haciendo predicciones sobre el conjunto de datos de prueba (como el conjunto de mezcla).
En el ejemplo que figura a continuación se evalúa cada uno de los modelos base de forma aislada en el conjunto de datos de modelización predictiva de regresión sintética.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
# Evaluar los modelos base de forma aislada en el conjunto de datos de regresión de numpy importación hstack de sklearn.conjuntos de datos importación make_regression de sklearn.model_selection importación prueba_de_trenes_split de sklearn.métrica importación error_absoluto_medio de sklearn.modelo_lineal importación LinearRegression de sklearn.vecinos importación KNeighborsRegressor de sklearn.árbol importación DecisionTreeRegressor de sklearn.svm importación SVR # Obtener el conjunto de datos def get_dataset(): X, y = make_regression(n_muestras=10000, n_funciones=20, n_informativo=10, ruido=0.3, estado_aleatorio=7) volver X, y # Obtener una lista de modelos base def get_models(): modelos = lista() modelos.anexar((«lr, LinearRegression())) modelos.anexar((«knn, KNeighborsRegressor())) modelos.anexar((«carro, DecisionTreeRegressor())) modelos.anexar((«svm, SVR())) volver modelos # Definir el conjunto de datos X, y = get_dataset() # Dividir el conjunto de datos en trenes y conjuntos de pruebas X_tren_completo, X_test, y_entrenamiento_completo, y_test = prueba_de_trenes_split(X, y, tamaño_de_prueba=0.5, estado_aleatorio=1) # Integrar la división de los datos imprimir(«Tren: %s, Prueba: %s % (X_tren_completo.forma, X_test.forma)) # Crear los modelos base modelos = get_models() # Evaluar el modelo independiente para nombre, modelo en modelos: # Encajar el modelo en el conjunto de datos de entrenamiento modelo.encajar(X_tren_completo, y_entrenamiento_completo) # Hacer una predicción en el conjunto de datos de la prueba yhat = modelo.predecir(X_test) # Evaluar las predicciones puntuación = error_absoluto_medio(y_test, yhat) # Reportar el resultado… imprimir(‘>%s MAE: %.3f’ % (nombre, puntuación)) |
Ejecutando el ejemplo primero reporta la forma del tren completo y los conjuntos de datos de prueba, luego el MAE de cada modelo base en el conjunto de datos de prueba.
Nota: Sus resultados pueden variar dada la naturaleza estocástica del algoritmo o el procedimiento de evaluación, o las diferencias en la precisión numérica. Considere ejecutar el ejemplo unas cuantas veces y compare el resultado promedio.
En este caso, podemos ver que, de hecho, el modelo de regresión lineal ha funcionado ligeramente mejor que el conjunto de mezcla, logrando un MAE de 0,236 en comparación con el 0,237 con el conjunto. Esto puede deberse a la forma en que se construyó el conjunto de datos sintéticos.
Sin embargo, en este caso, elegiríamos usar el modelo de regresión lineal directamente en este problema. Esto resalta la importancia de comprobar el rendimiento de los modelos contribuyentes antes de adoptar un modelo de conjunto como modelo final.
|
Tren: (5000, 20), Prueba: (5000, 20) >lr MAE: 0.236 >knn MAE: 100.169 >carro MAE: 133.744 >svm MAE: 138.195 |
De nuevo, podemos elegir usar un conjunto de mezcla como nuestro modelo final para la regresión.
Esto implica el ajuste de la división del conjunto de datos en conjuntos de tren y validación para ajustar la base y los meta-modelos respectivamente, entonces el conjunto puede ser usado para hacer una predicción para una nueva fila de datos.
El ejemplo completo de hacer una predicción sobre nuevos datos con un conjunto de mezcla para la regresión se enumera a continuación.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 |
# ejemplo de hacer una predicción con un conjunto de mezcla para la regresión de numpy importación hstack de sklearn.conjuntos de datos importación make_regression de sklearn.model_selection importación prueba_de_trenes_split de sklearn.modelo_lineal importación LinearRegression de sklearn.vecinos importación KNeighborsRegressor de sklearn.árbol importación DecisionTreeRegressor de sklearn.svm importación SVR # Obtener el conjunto de datos def get_dataset(): X, y = make_regression(n_muestras=10000, n_funciones=20, n_informativo=10, ruido=0.3, estado_aleatorio=7) volver X, y # Obtener una lista de modelos base def get_models(): modelos = lista() modelos.anexar((«lr, LinearRegression())) modelos.anexar((«knn, KNeighborsRegressor())) modelos.anexar((«carro, DecisionTreeRegressor())) modelos.anexar((«svm, SVR())) volver modelos # Encaja en el conjunto de la mezcla def fit_ensemble(modelos, X_tren, X_val, y_tren, y_val): # Encajar todos los modelos en el set de entrenamiento y predecir en el set de espera meta_X = lista() para _, modelo en modelos: # Encajar en el set de entrenamiento modelo.encajar(X_tren, y_tren) # Predecir en el set de espera yhat = modelo.predecir(X_val) # remodelar las predicciones en una matriz con una columna yhat = yhat.remodelar(len(yhat), 1) # Almacenar las predicciones como entrada para la mezcla meta_X.anexar(yhat) # Crear una matriz 2d a partir de las predicciones, cada conjunto es una característica de entrada meta_X = hstack(meta_X) # Definir el modelo de mezcla licuadora = LinearRegression() # Encajar en las predicciones de los modelos de base licuadora.encajar(meta_X, y_val) volver licuadora # Hacer una predicción con el conjunto de la mezcla def predict_ensemble(modelos, licuadora, X_test): # Hacer predicciones con modelos de base meta_X = lista() para _, modelo en modelos: # predecir con el modelo base yhat = modelo.predecir(X_test) # remodelar las predicciones en una matriz con una columna yhat = yhat.remodelar(len(yhat), 1) # Predicción de la tienda meta_X.anexar(yhat) # Crear una matriz 2d a partir de las predicciones, cada conjunto es una característica de entrada meta_X = hstack(meta_X) # Predecir volver licuadora.predecir(meta_X) # Definir el conjunto de datos X, y = get_dataset() # Dividir el conjunto de datos en conjuntos de tren y validación X_tren, X_val, y_tren, y_val = prueba_de_trenes_split(X, y, tamaño_de_prueba=0.33, estado_aleatorio=1) # Integrar la división de los datos imprimir(«Tren: %s, Val: %s % (X_tren.forma, X_val.forma)) # Crear los modelos base modelos = get_models() # entrenar el conjunto de mezcla licuadora = fit_ensemble(modelos, X_tren, X_val, y_tren, y_val) # hacer una predicción en una nueva fila de datos fila = [[–0.24038754, 0.55423865, –0.48979221, 1.56074459, –1.16007611, 1.10049103, 1.18385406, –1.57344162, 0.97862519, –0.03166643, 1.77099821, 1.98645499, 0.86780193, 2.01534177, 2.51509494, –1.04609004, –0.19428148, –0.05967386, –2.67168985, 1.07182911] yhat = predict_ensemble(modelos, licuadora, [[fila]) # resumir la predicción imprimir(«Predicho: %.3f % (yhat[[0])) |
La ejecución del ejemplo encaja con el modelo de conjunto de mezcla en el conjunto de datos y luego se utiliza para hacer una predicción sobre una nueva fila de datos, como podríamos hacer al utilizar el modelo en una aplicación.
|
Tren: (6700, 20), Val: (3300, 20) Predicho: 359.986 |
Más lecturas
Esta sección proporciona más recursos sobre el tema si desea profundizar en él.
Tutoriales relacionados
Documentos
Artículos
Resumen
En este tutorial, descubriste cómo desarrollar y evaluar un conjunto de mezclas en pitón.
Específicamente, aprendiste:
- Los conjuntos mixtos son un tipo de apilamiento en el que el metomodelo se ajusta utilizando predicciones sobre un conjunto de datos de validación de la retención en lugar de predicciones fuera de la retención.
- Cómo desarrollar un conjunto de mezclas, incluyendo funciones para entrenar el modelo y hacer predicciones sobre nuevos datos.
- Cómo evaluar los conjuntos de mezclas para la clasificación y la regresión de los problemas de modelado predictivo.
¿Tiene alguna pregunta?
Haga sus preguntas en los comentarios de abajo y haré lo posible por responder.