Última actualización el 28 de agosto de 2020
La regresión de salida múltiple implica la predicción de dos o más variables numéricas.
A diferencia de la regresión normal, en la que se predice un único valor para cada muestra, la regresión de salida múltiple requiere algoritmos especializados de aprendizaje automático que permitan obtener múltiples variables para cada predicción.
Las redes neuronales de aprendizaje profundo son un ejemplo de un algoritmo que soporta de forma nativa problemas de regresión de múltiples salidas. Los modelos de redes neuronales para tareas de regresión de múltiples salidas pueden ser fácilmente definidos y evaluados usando la biblioteca de aprendizaje profundo de Keras.
En este tutorial, descubrirá cómo desarrollar modelos de aprendizaje profundo para la regresión multi-salida.
Después de completar este tutorial, lo sabrás:
- La regresión multi-salida es una tarea de modelado predictivo que involucra dos o más variables de salida numéricas.
- Los modelos de redes neuronales pueden ser configurados para tareas de regresión de múltiples salidas.
- Cómo evaluar una red neuronal para la regresión de múltiples salidas y hacer una predicción para nuevos datos.
Empecemos.
Modelos de Aprendizaje Profundo para la Regresión Multi-Salida
Foto de Christian Collins, algunos derechos reservados.
Resumen del Tutorial
Este tutorial está dividido en tres partes; son:
- Regresión multi-salida
- Redes neuronales para múltiples salidas
- Red neuronal para la regresión multi-salida
Regresión multi-salida
La regresión es una tarea de modelado predictivo que implica la predicción de una salida numérica dada alguna entrada.
Es diferente de las tareas de clasificación que implican la predicción de una etiqueta de clase.
Típicamente, una tarea de regresión implica la predicción de un único valor numérico. Aunque algunas tareas requieren predecir más de un valor numérico. Estas tareas se denominan regresión de salida múltipleo una regresión de múltiples salidas para abreviar.
En la regresión de múltiples salidas, se requieren dos o más salidas para cada muestra de entrada, y las salidas se requieren simultáneamente. Se supone que las salidas son una función de las entradas.
Podemos crear un conjunto de datos de regresión sintética multi-salida usando la función make_regression() en la biblioteca scikit-learn.
Nuestro conjunto de datos tendrá 1.000 muestras con 10 características de entrada, cinco de las cuales serán relevantes para la salida y cinco de las cuales serán redundantes. El conjunto de datos tendrá tres salidas numéricas para cada muestra.
El ejemplo completo de creación y resumen del conjunto de datos de regresión sintética multi-salida se enumera a continuación.
|
# Ejemplo de un problema de regresión de múltiples salidas de sklearn.conjuntos de datos importación hacer_regresión # Crear un conjunto de datos X, y = make_regression(n_muestras=1000, n_funciones=10, n_informativo=5, n_targets=3, estado_aleatorio=2) # Resumir la forma imprimir(X.forma, y.forma) |
Ejecutando el ejemplo se crea el conjunto de datos y se resume la forma de los elementos de entrada y salida.
Podemos ver que, como era de esperar, hay 1.000 muestras, cada una con 10 características de entrada y tres de salida.
A continuación, veamos cómo podemos desarrollar modelos de redes neuronales para tareas de regresión de salida múltiple.
Redes neuronales para múltiples salidas
Muchos algoritmos de aprendizaje de máquinas soportan la regresión multi-salida de forma nativa.
Ejemplos populares son los árboles de decisión y los conjuntos de árboles de decisión. Una limitación de los árboles de decisión para la regresión de múltiples salidas es que las relaciones entre las entradas y las salidas pueden ser bloqueadas o muy estructuradas en función de los datos de la formación.
Los modelos de redes neuronales también admiten la regresión multi-salida y tienen el beneficio de aprender una función continua que puede modelar una relación más graciosa entre los cambios en la entrada y la salida.
La regresión multi-salida puede ser soportada directamente por las redes neuronales simplemente especificando el número de variables objetivo que hay en el problema como el número de nodos en la capa de salida. Por ejemplo, una tarea que tiene tres variables de salida requerirá una capa de salida de la red neuronal con tres nodos en la capa de salida, cada uno con la función de activación lineal (por defecto).
Podemos demostrarlo usando la biblioteca de aprendizaje profundo de Keras.
Definiremos un modelo de perceptrón multicapa (MLP) para la tarea de regresión de salida múltiple definida en la sección anterior.
Cada muestra tiene 10 entradas y tres salidas, por lo tanto, la red requiere una capa de entrada que espera 10 entradas especificadas a través del «input_dim«en la primera capa oculta y tres nodos en la capa de salida.
Usaremos la popular función de activación de ReLU en la capa oculta. La capa oculta tiene 20 nodos, que fueron elegidos después de algún ensayo y error. Ajustaremos el modelo usando la pérdida media de error absoluto (MAE) y la versión de Adán del descenso de gradiente estocástico.
La definición de la red para la tarea de regresión multi-salida se enumera a continuación.
|
... # Definir el modelo modelo = Secuencial() modelo.añadir(Densa(20, input_dim=10, kernel_inicializador=‘he_uniforme’, activación=«relu)) modelo.añadir(Densa(3)) modelo.compilar(pérdida=«mae, optimizador=«adam) |
Es posible que desee adaptar este modelo para su propia tarea de regresión multi-salida, por lo tanto, podemos crear una función para definir y devolver el modelo donde el número de variables de entrada y el número de variables de salida se proporcionan como argumentos.
|
# Consigue el modelo def get_model(n_inputs, n_salidas): modelo = Secuencial() modelo.añadir(Densa(20, input_dim=n_inputs, kernel_inicializador=‘he_uniforme’, activación=«relu)) modelo.añadir(Densa(n_salidas)) modelo.compilar(pérdida=«mae, optimizador=«adam) volver modelo |
Ahora que estamos familiarizados con la forma de definir un MLP para la regresión multi-salida, vamos a explorar cómo se puede evaluar este modelo.
Red neuronal para la regresión multi-salida
Si el conjunto de datos es pequeño, es una buena práctica evaluar los modelos de redes neuronales repetidamente en el mismo conjunto de datos y reportar el rendimiento medio a través de las repeticiones.
Esto se debe a la naturaleza estocástica del algoritmo de aprendizaje.
Además, es una buena práctica utilizar la validación cruzada del pliegue k en lugar de las divisiones de tren/prueba de un conjunto de datos para obtener una estimación imparcial del rendimiento del modelo cuando se hacen predicciones sobre nuevos datos. Una vez más, sólo si no hay demasiados datos y el proceso puede completarse en un tiempo razonable.
Teniendo esto en cuenta, evaluaremos el modelo MLP en la tarea de regresión multi-salida utilizando la validación cruzada repetida k-pliegue con 10 pliegues y tres repeticiones.
Cada pliegue del modelo se define, se ajusta y se evalúa. Se recogen las puntuaciones y se pueden resumir informando de la media y la desviación estándar.
El evaluate_model() toma el conjunto de datos, evalúa el modelo y devuelve una lista de resultados de evaluación, en este caso, los resultados del MAE.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
# Evaluar un modelo usando la validación cruzada repetida del pliegue k def evaluate_model(X, y): resultados = lista() n_inputs, n_salidas = X.forma[[1], y.forma[[1] # Definir el procedimiento de evaluación cv = RepetidoKFold(n_splits=10, n_repeticiones=3, estado_aleatorio=1) # enumerar los pliegues para train_ix, test_ix en cv.split(X): # Preparar los datos X_tren, X_test = X[[train_ix], X[[test_ix] y_tren, y_test = y[[train_ix], y[[test_ix] # Definir el modelo modelo = get_model(n_inputs, n_salidas) # Modelo de ajuste modelo.encajar(X_tren, y_tren, verboso=0, épocas=100) # Evaluar el modelo en el conjunto de pruebas mae = modelo.evalúa(X_test, y_test, verboso=0) # Almacenar el resultado imprimir(‘>%.3f’ % mae) resultados.anexar(mae) volver resultados |
Podemos entonces cargar nuestro conjunto de datos y evaluar el modelo e informar del rendimiento medio.
A continuación se muestra el ejemplo completo.
|
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 |
# mlp para la regresión de multi-salida de numpy importación significa de numpy importación std de sklearn.conjuntos de datos importación make_regression de sklearn.model_selection importación RepetidoKFold de keras.modelos importación Secuencial de keras.capas importación Densa # Obtener el conjunto de datos def get_dataset(): X, y = make_regression(n_muestras=1000, n_funciones=10, n_informativo=5, n_targets=3, estado_aleatorio=2) volver X, y # Consigue el modelo def get_model(n_inputs, n_salidas): modelo = Secuencial() modelo.añadir(Densa(20, input_dim=n_inputs, kernel_inicializador=‘he_uniforme’, activación=«relu)) modelo.añadir(Densa(n_salidas)) modelo.compilar(pérdida=«mae, optimizador=«adam) volver modelo # Evaluar un modelo usando la validación cruzada repetida del pliegue k def evaluate_model(X, y): resultados = lista() n_inputs, n_salidas = X.forma[[1], y.forma[[1] # Definir el procedimiento de evaluación cv = RepetidoKFold(n_splits=10, n_repeticiones=3, estado_aleatorio=1) # enumerar los pliegues para train_ix, test_ix en cv.split(X): # Preparar los datos X_tren, X_test = X[[train_ix], X[[test_ix] y_tren, y_test = y[[train_ix], y[[test_ix] # Definir el modelo modelo = get_model(n_inputs, n_salidas) # Modelo de ajuste modelo.encajar(X_tren, y_tren, verboso=0, épocas=100) # Evaluar el modelo en el conjunto de pruebas mae = modelo.evalúa(X_test, y_test, verboso=0) # Almacenar el resultado imprimir(‘>%.3f’ % mae) resultados.anexar(mae) volver resultados # Cargar conjunto de datos X, y = get_dataset() # Evaluar el modelo resultados = evaluate_model(X, y) # Resumir el rendimiento imprimir(MAE: %.3f (%.3f)’. % (significa(resultados), std(resultados))) |
Ejecutando el ejemplo se informa el MAE para cada pliegue y cada repetición, para dar una idea del progreso de la evaluación.
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.
Al final, se informa de la media y la desviación estándar MAE. En este caso, se muestra que el modelo alcanza un MAE de alrededor de 8.184.
Puede utilizar este código como plantilla para evaluar los modelos MLP en sus propias tareas de regresión multi-salida. El número de nodos y capas en el modelo puede ser fácilmente adaptado y ajustado a la complejidad de su conjunto de datos.
|
… >8.054 >7.562 >9.026 >8.541 >6.744 MAE: 8.184 (1.032) |
Una vez elegida la configuración del modelo, podemos utilizarla para ajustar un modelo final en todos los datos disponibles y hacer una predicción para los nuevos datos.
El siguiente ejemplo lo demuestra ajustando primero el modelo MLP en todo el conjunto de datos de regresión multi-salida, y luego llamando al predecir() en el modelo guardado para hacer una predicción para una nueva fila de datos.
|
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 |
# Usar mlp para la predicción de la regresión de salida múltiple de numpy importación asarray de sklearn.conjuntos de datos importación make_regression de keras.modelos importación Secuencial de keras.capas importación Densa # Obtener el conjunto de datos def get_dataset(): X, y = make_regression(n_muestras=1000, n_funciones=10, n_informativo=5, n_targets=3, estado_aleatorio=2) volver X, y # Consigue el modelo def get_model(n_inputs, n_salidas): modelo = Secuencial() modelo.añadir(Densa(20, input_dim=n_inputs, kernel_inicializador=‘he_uniforme’, activación=«relu)) modelo.añadir(Densa(n_salidas, kernel_inicializador=‘he_uniforme’)) modelo.compilar(pérdida=«mae, optimizador=«adam) volver modelo # Cargar conjunto de datos X, y = get_dataset() n_inputs, n_salidas = X.forma[[1], y.forma[[1] # Consigue un modelo modelo = get_model(n_inputs, n_salidas) # Encajar el modelo en todos los datos modelo.encajar(X, y, verboso=0, épocas=100) # hacer una predicción para los nuevos datos fila = [[–0.99859353,2.19284309,–0.42632569,–0.21043258,–1.13655612,–0.55671602,–0.63169045,–0.87625098,–0.99445578,–0.3677487] newX = asarray([[fila]) yhat = modelo.predecir(newX) imprimir(«Predicho: %s % yhat[[0]) |
Ejecutando el ejemplo se ajusta al modelo y hace una predicción para una nueva fila.
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.
Como era de esperar, la predicción contiene tres variables de salida necesarias para la tarea de regresión de salida múltiple.
|
Predicho: [-152.22713 -78.04891 -91.97194] |