El autoencoder es un tipo de red neuronal que puede ser utilizado para aprender una representación comprimida de los datos en bruto.
Un autoencoder está compuesto por submodelos de codificador y decodificador. El codificador comprime la entrada y el decodificador intenta recrear la entrada a partir de la versión comprimida proporcionada por el codificador. Después de la formación, el modelo de codificador se guarda y el decodificador se descarta.
El codificador puede utilizarse entonces como técnica de preparación de datos para realizar la extracción de características en los datos en bruto que pueden utilizarse para entrenar un modelo diferente de aprendizaje de la máquina.
En este tutorial, descubrirá cómo desarrollar y evaluar un autoencoder para la predicción de la regresión
Después de completar este tutorial, lo sabrás:
- Un autoencoder es un modelo de red neural que puede ser usado para aprender una representación comprimida de los datos en bruto.
- Cómo entrenar un modelo de autoencoder en un conjunto de datos de entrenamiento y guardar sólo la parte de codificador del modelo.
- Cómo usar el codificador como un paso de preparación de datos cuando se entrena un modelo de aprendizaje de una máquina.
Empecemos.
Extracción de características del autocoder para la regresión
Foto de Simon Matzinger, algunos derechos reservados.
Resumen del Tutorial
Este tutorial está dividido en tres partes; son:
- Autocodificadores para la extracción de características
- Autoencoder para la regresión
- Autoencoder como preparación de datos
Autocodificadores para la extracción de características
Un autoencoder es un modelo de red neural que busca aprender una representación comprimida de una entrada.
Un autoencoder es una red neural que está entrenada para intentar copiar su entrada a su salida.
– Página 502, Aprendizaje profundo, 2016.
Se trata de un método de aprendizaje no supervisado, aunque técnicamente se les entrena utilizando métodos de aprendizaje supervisados, denominados auto-supervisados. Por lo general, se les entrena como parte de un modelo más amplio que intenta recrear la entrada.
Por ejemplo:
El diseño del modelo de autoencoder lo hace difícil a propósito, restringiendo la arquitectura a un cuello de botella en el punto medio del modelo, a partir del cual se realiza la reconstrucción de los datos de entrada.
Hay muchos tipos de autocodificadores y su uso varía, pero quizás el uso más común es como modelo de extracción de características aprendidas o automáticas.
En este caso, una vez que el modelo se ajusta, el aspecto de la reconstrucción del modelo puede ser descartado y el modelo hasta el punto del cuello de botella puede ser utilizado. La salida del modelo en el cuello de botella es un vector de longitud fija que proporciona una representación comprimida de los datos de entrada.
Por lo general, están restringidos de manera que sólo pueden copiar aproximadamente, y copiar sólo la entrada que se asemeja a los datos de entrenamiento. Dado que el modelo se ve obligado a priorizar los aspectos de la entrada que deben ser copiados, a menudo aprende propiedades útiles de los datos.
– Página 502, Aprendizaje profundo, 2016.
Los datos de entrada del dominio pueden entonces proporcionarse al modelo y la salida del modelo en el cuello de botella puede utilizarse como un vector de características en un modelo de aprendizaje supervisado, para la visualización o, más en general, para la reducción de la dimensionalidad.
A continuación, exploremos cómo podríamos desarrollar un autocoder para la extracción de características en un problema de modelado predictivo de regresión.
Autoencoder para la regresión
En esta sección, desarrollaremos un autoencoder para aprender una representación comprimida de las características de entrada para un problema de modelado predictivo de regresión.
Primero, definamos un problema de modelado predictivo de regresión.
Utilizaremos la función scikit-learn de make_regression() para definir una tarea de regresión sintética con 100 características de entrada (columnas) y 1.000 ejemplos (filas). Es importante que definamos el problema de tal manera que la mayoría de las variables de entrada sean redundantes (90 del 100 o 90 por ciento), permitiendo que el autoencoder aprenda más tarde una representación comprimida útil.
El ejemplo que figura a continuación define el conjunto de datos y resume su forma.
|
# Conjunto de datos de regresión sintética de sklearn.conjuntos de datos importación hacer_regresión # Definir el conjunto de datos X, y = make_regression(n_muestras=1000, n_funciones=100, n_informativo=10, ruido=0.1, estado_aleatorio=1) # resumir el conjunto de datos imprimir(X.forma, y.forma) |
Ejecutando el ejemplo se define el conjunto de datos y se imprime la forma de los conjuntos, confirmando el número de filas y columnas.
A continuación, desarrollaremos un modelo de autoencoder de Percepción Multicapa (MLP).
El modelo tomará todas las columnas de entrada, y luego producirá los mismos valores. Aprenderá a recrear el patrón de entrada exactamente.
El autoencoder consta de dos partes: el codificador y el decodificador. El codificador aprende a interpretar la entrada y a comprimirla en una representación interna definida por la capa del cuello de botella. El decodificador toma la salida del codificador (la capa de cuello de botella) e intenta recrear la entrada.
Una vez que el autoencoder es entrenado, la decodificación es descartada y sólo conservamos el codificador y lo usamos para comprimir los ejemplos de entrada a los vectores de salida por la capa de cuello de botella.
En este primer autocoder, no comprimiremos la entrada en absoluto y usaremos una capa de cuello de botella del mismo tamaño que la entrada. Esto debería ser un problema fácil que el modelo aprenderá casi a la perfección y tiene como objetivo confirmar que nuestro modelo se implementa correctamente.
Definiremos el modelo utilizando la API funcional. Si esto es nuevo para usted, le recomiendo este tutorial:
Antes de definir y ajustar el modelo, dividiremos los datos en trenes y conjuntos de pruebas y escalaremos los datos de entrada normalizando los valores al rango 0-1, una buena práctica con los MLP.
|
... # Dividido en conjuntos de prueba de trenes X_tren, X_test, y_tren, y_test = prueba_de_trenes_split(X, y, tamaño_de_prueba=0.33, estado_aleatorio=1) # datos de la escala t = MinMaxScaler() t.encajar(X_tren) X_tren = t.Transformar(X_tren) X_test = t.Transformar(X_test) |
Definiremos el codificador para que tenga una capa oculta con el mismo número de nodos que hay en los datos de entrada con la normalización de los lotes y la activación de ReLU.
A esto le sigue una capa de cuello de botella con el mismo número de nodos que las columnas de los datos de entrada, por ejemplo, sin compresión.
|
... # definir codificador visible = Entrada(forma=(n_inputs,)) e = Densa(n_inputs*2)(visible) e = BatchNormalization()(e) e = ReLU()(e) # Definir el cuello de botella n_bottleneck = n_inputs cuello de botella = Densa(n_bottleneck)(e) |
El decodificador se definirá con la misma estructura.
Tendrá una capa oculta con normalización de lotes y activación de ReLU. La capa de salida tendrá el mismo número de nodos que hay columnas en los datos de entrada y utilizará una función de activación lineal para emitir valores numéricos.
|
... # Definir el decodificador d = Densa(n_inputs*2)(cuello de botella) d = BatchNormalization()(d) d = ReLU()(d) # Capa de salida salida = Densa(n_inputs, activación=«lineal)(d) # Definir el modelo de autoencoder modelo = Modelo(aportaciones=visible, salidas=salida) # compilar el modelo de autoencoder modelo.compilar(optimizador=«adam, pérdida=«mse) |
El modelo se ajustará utilizando la versión eficiente de Adam de descenso de gradiente estocástico y minimiza el error cuadrático medio, dado que la reconstrucción es un tipo de problema de regresión multi-salida.
|
... # compilar el modelo de autoencoder modelo.compilar(optimizador=«adam, pérdida=«mse) |
Podemos trazar las capas en el modelo de auto-codificación para tener una idea de cómo los datos fluyen a través del modelo.
|
... # Trazar el autoencoder modelo_de_trama(modelo, ‘autoencoder.png’, mostrar_formas=Verdadero) |
La imagen de abajo muestra un gráfico del autoencoder.
Esquema del modelo de autoencoder para la regresión
A continuación, podemos entrenar al modelo para reproducir la entrada y hacer un seguimiento del rendimiento del modelo en el conjunto de pruebas de retención. El modelo se entrena para 400 épocas y un tamaño de lote de 16 ejemplos.
|
... # Encajar el modelo de autoencoder para reconstruir la entrada historia = modelo.encajar(X_tren, X_tren, épocas=400, tamaño_de_lote=16, verboso=2, datos_de_validación=(X_test,X_test)) |
Después del entrenamiento, podemos trazar las curvas de aprendizaje del tren y los juegos de prueba para confirmar que el modelo aprendió bien el problema de la reconstrucción.
|
... # Pérdida de la trama pyplot.parcela(historia.historia[[«pérdida], etiqueta=«tren) pyplot.parcela(historia.historia[[‘val_loss’], etiqueta=«prueba) pyplot.leyenda() pyplot.mostrar() |
Por último, podemos guardar el modelo de codificador para usarlo más tarde, si se desea.
|
... # Definir un modelo de codificador (sin el decodificador) codificador = Modelo(aportaciones=visible, salidas=cuello de botella) modelo_de_trama(codificador, «codificador.png, mostrar_formas=Verdadero) # Guarda el codificador en un archivo codificador.guardar(«codificador.h5) |
Como parte de guardar el codificador, también trazaremos el modelo para tener una idea de la forma de la salida de la capa de cuello de botella, por ejemplo, un vector de 100 elementos.
A continuación se presenta un ejemplo de esta trama.
Esquema del modelo de codificador para la regresión sin compresión
Uniendo todo esto, el ejemplo completo de un autoencoder para reconstruir los datos de entrada para un conjunto de datos de regresión sin ninguna compresión en la capa de cuello de botella 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 |
# Entrena el autoencoder para la regresión sin compresión en la capa del cuello de botella de sklearn.conjuntos de datos importación make_regression de sklearn.preprocesamiento importación MinMaxScaler de sklearn.model_selection importación prueba_de_trenes_split de tensorflow.keras.modelos importación Modelo de tensorflow.keras.capas importación Entrada de tensorflow.keras.capas importación Densa de tensorflow.keras.capas importación ReLU de tensorflow.keras.capas importación BatchNormalization de tensorflow.keras.utils importación modelo_de_trama de matplotlib importación pyplot # Definir el conjunto de datos X, y = make_regression(n_muestras=1000, n_funciones=100, n_informativo=10, ruido=0.1, estado_aleatorio=1) # Número de columnas de entrada n_inputs = X.forma[[1] # Dividido en conjuntos de prueba de trenes X_tren, X_test, y_tren, y_test = prueba_de_trenes_split(X, y, tamaño_de_prueba=0.33, estado_aleatorio=1) # datos de la escala t = MinMaxScaler() t.encajar(X_tren) X_tren = t.Transformar(X_tren) X_test = t.Transformar(X_test) # definir codificador visible = Entrada(forma=(n_inputs,)) e = Densa(n_inputs*2)(visible) e = BatchNormalization()(e) e = ReLU()(e) # Definir el cuello de botella n_bottleneck = n_inputs cuello de botella = Densa(n_bottleneck)(e) # Definir el decodificador d = Densa(n_inputs*2)(cuello de botella) d = BatchNormalization()(d) d = ReLU()(d) # Capa de salida salida = Densa(n_inputs, activación=«lineal)(d) # Definir el modelo de autoencoder modelo = Modelo(aportaciones=visible, salidas=salida) # compilar el modelo de autoencoder modelo.compilar(optimizador=«adam, pérdida=«mse) # Trazar el autoencoder modelo_de_trama(modelo, ‘autoencoder.png’, mostrar_formas=Verdadero) # Encajar el modelo de autoencoder para reconstruir la entrada historia = modelo.encajar(X_tren, X_tren, épocas=400, tamaño_de_lote=16, verboso=2, datos_de_validación=(X_test,X_test)) # Pérdida de la trama pyplot.parcela(historia.historia[[«pérdida], etiqueta=«tren) pyplot.parcela(historia.historia[[‘val_loss’], etiqueta=«prueba) pyplot.leyenda() pyplot.mostrar() # Definir un modelo de codificador (sin el decodificador) codificador = Modelo(aportaciones=visible, salidas=cuello de botella) modelo_de_trama(codificador, «codificador.png, mostrar_formas=Verdadero) # Guarda el codificador en un archivo codificador.guardar(«codificador.h5) |
Ejecutando el ejemplo se ajusta al modelo e informa de la pérdida en el tren y los juegos de prueba a lo largo del camino.
Notasi tienes problemas para crear las tramas del modelo, puedes comentar la importación y llamar al plot_model() funció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.
En este caso, vemos que la pérdida es baja pero no llega a cero (como podíamos haber esperado) sin compresión en la capa del cuello de botella. Tal vez se requiera un mayor ajuste de la arquitectura del modelo o el aprendizaje de hiperparámetros.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
… Época 393/400 42/42 – 0s – pérdida: 0.0025 – val_loss: 0.0024 Época 394/400 42/42 – 0s – pérdida: 0.0025 – val_loss: 0.0021 Época 395/400 42/42 – 0s – pérdida: 0.0023 – val_loss: 0.0021 Época 396/400 42/42 – 0s – pérdida: 0.0025 – val_loss: 0.0023 Época 397/400 42/42 – 0s – pérdida: 0.0024 – val_loss: 0.0022 Época 398/400 42/42 – 0s – pérdida: 0.0025 – val_loss: 0.0021 Época 399/400 42/42 – 0s – pérdida: 0.0026 – val_loss: 0.0022 Época 400/400 42/42 – 0s – pérdida: 0.0025 – val_loss: 0.0024 |
Se crea un gráfico de las curvas de aprendizaje que muestra que el modelo logra un buen ajuste en la reconstrucción de la entrada, que se mantiene constante a lo largo del entrenamiento, no en exceso.
Curvas de aprendizaje del modelo de autoencoder para la regresión sin compresión
Hasta ahora, todo bien. Sabemos cómo desarrollar un autoencoder sin compresión.
El codificador entrenado se guarda en el archivo «codificador.h5«que podemos cargar y usar más tarde.
A continuación, exploremos cómo podríamos usar el modelo de codificador entrenado.
Autoencoder como preparación de datos
En esta sección, utilizaremos el modelo de codificador entrenado del modelo de autoencoder para comprimir los datos de entrada y entrenar un modelo predictivo diferente.
Primero, establezcamos una línea de base en el desempeño de este problema. Esto es importante, ya que si el rendimiento de un modelo no mejora con la codificación comprimida, entonces la codificación comprimida no añade valor al proyecto y no debe utilizarse.
Podemos entrenar un modelo de regresión del vector de apoyo (SVR) en el conjunto de datos de entrenamiento directamente y evaluar el rendimiento del modelo en el conjunto de pruebas de retención.
Como es una buena práctica, escalaremos tanto las variables de entrada como las de destino antes de ajustar y evaluar el modelo.
El ejemplo completo figura 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 |
# línea de base en el rendimiento con el modelo de regresión del vector de apoyo de sklearn.conjuntos de datos importación make_regression de sklearn.preprocesamiento importación MinMaxScaler de sklearn.model_selection importación prueba_de_trenes_split de sklearn.svm importación SVR de sklearn.métrica importación media_absoluta_error # Definir el conjunto de datos X, y = make_regression(n_muestras=1000, n_funciones=100, n_informativo=10, ruido=0.1, estado_aleatorio=1) # Dividido en conjuntos de prueba de trenes X_tren, X_test, y_tren, y_test = prueba_de_trenes_split(X, y, tamaño_de_prueba=0.33, estado_aleatorio=1) # remodelar las variables del objetivo para que podamos transformarlas y_tren = y_tren.remodelar((len(y_tren), 1)) y_test = y_test.remodelar((len(y_test), 1)) # escalar los datos de entrada trans_in = MinMaxScaler() trans_in.encajar(X_tren) X_tren = trans_in.Transformar(X_tren) X_test = trans_in.Transformar(X_test) # Escala los datos de salida trans_out = MinMaxScaler() trans_out.encajar(y_tren) y_tren = trans_out.Transformar(y_tren) y_test = trans_out.Transformar(y_test) # Definir el modelo modelo = SVR() # Modelo de ajuste en el conjunto de datos de entrenamiento modelo.encajar(X_tren, y_tren) # Hacer la predicción en el equipo de pruebas yhat = modelo.predecir(X_test) # invierte las transformaciones para que podamos calcular los errores yhat = yhat.remodelar((len(yhat), 1)) yhat = trans_out.transformación_inversa(yhat) y_test = trans_out.transformación_inversa(y_test) # calcular el error puntuación = error_absoluto_medio(y_test, yhat) imprimir(puntuación) |
Al ejecutar el ejemplo se ajusta un modelo de SVR en el conjunto de datos de entrenamiento y se evalúa en el conjunto de pruebas.
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 modelo alcanza un error absoluto medio (MAE) de alrededor de 89.
Esperamos y deseamos que un modelo SVR se ajuste a una versión codificada de la entrada para lograr un menor error para que la codificación se considere útil.
Podemos actualizar el ejemplo para codificar primero los datos utilizando el modelo de codificador entrenado en la sección anterior.
Primero, podemos cargar el modelo de codificador entrenado desde el archivo.
|
... # Cargar el modelo desde el archivo codificador = load_model(«codificador.h5) |
Podemos entonces utilizar el codificador para transformar los datos de entrada en bruto (por ejemplo, 100 columnas) en vectores de cuello de botella (por ejemplo, 100 vectores de elementos).
Este proceso puede aplicarse al tren y a los conjuntos de datos de prueba.
|
... # codificar los datos del tren X_código_de_trenes = codificador.predecir(X_tren) # codificar los datos de la prueba X_test_encode = codificador.predecir(X_test) |
Podemos entonces usar estos datos codificados para entrenar y evaluar el modelo SVR, como antes.
|
... # Definir el modelo modelo = SVR() # Modelo de ajuste en el conjunto de datos de entrenamiento modelo.encajar(X_código_de_trenes, y_tren) # Hacer la predicción en el equipo de pruebas yhat = modelo.predecir(X_test_encode) |
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 |
# Apoyar el rendimiento de la regresión vectorial con la entrada codificada de sklearn.conjuntos de datos importación make_regression de sklearn.preprocesamiento importación MinMaxScaler de sklearn.model_selection importación prueba_de_trenes_split de sklearn.svm importación SVR de sklearn.métrica importación error_absoluto_medio de tensorflow.keras.modelos importación carga_modelo # Definir el conjunto de datos X, y = make_regression(n_muestras=1000, n_funciones=100, n_informativo=10, ruido=0.1, estado_aleatorio=1) # Dividido en conjuntos de prueba de trenes X_tren, X_test, y_tren, y_test = prueba_de_trenes_split(X, y, tamaño_de_prueba=0.33, estado_aleatorio=1) # remodelar las variables del objetivo para que podamos transformarlas y_tren = y_tren.remodelar((len(y_tren), 1)) y_test = y_test.remodelar((len(y_test), 1)) # escalar los datos de entrada trans_in = MinMaxScaler() trans_in.encajar(X_tren) X_tren = trans_in.Transformar(X_tren) X_test = trans_in.Transformar(X_test) # Escala los datos de salida trans_out = MinMaxScaler() trans_out.encajar(y_tren) y_tren = trans_out.Transformar(y_tren) y_test = trans_out.Transformar(y_test) # Cargar el modelo desde el archivo codificador = load_model(«codificador.h5) # codificar los datos del tren X_código_de_trenes = codificador.predecir(X_tren) # codificar los datos de la prueba X_test_encode = codificador.predecir(X_test) # Definir el modelo modelo = SVR() # Modelo de ajuste en el conjunto de datos de entrenamiento modelo.encajar(X_código_de_trenes, y_tren) # Hacer la predicción en el equipo de pruebas yhat = modelo.predecir(X_test_encode) # invierte las transformaciones para que podamos calcular los errores yhat = yhat.remodelar((len(yhat), 1)) yhat = trans_out.transformación_inversa(yhat) y_test = trans_out.transformación_inversa(y_test) # calcular el error puntuación = error_absoluto_medio(y_test, yhat) imprimir(puntuación) |
Al ejecutar el ejemplo primero codifica el conjunto de datos utilizando el codificador, luego ajusta un modelo de SVR en el conjunto de datos de entrenamiento y lo evalúa en el conjunto de pruebas.
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 modelo alcanza un MAE de alrededor de 69.
Este es un mejor MAE que el mismo modelo evaluado en el conjunto de datos en bruto, lo que sugiere que la codificación es útil para nuestro modelo elegido y el arnés de prueba.
Más lecturas
Esta sección proporciona más recursos sobre el tema si desea profundizar en él.
Tutoriales
Libros
APIs
Artículos
Resumen
En este tutorial, descubriste cómo desarrollar y evaluar un autoencoder para el modelado predictivo de regresión.
Específicamente, aprendiste:
- Un autoencoder es un modelo de red neuronal que puede ser usado para aprender una representación comprimida de los datos en bruto.
- Cómo entrenar un modelo de autoencoder en un conjunto de datos de entrenamiento y guardar sólo la parte de codificador del modelo.
- Cómo usar el codificador como un paso de preparación de datos cuando se entrena un modelo de aprendizaje de una máquina.
¿Tiene alguna pregunta?
Haga sus preguntas en los comentarios de abajo y haré lo posible por responder.
Desarrollar proyectos de aprendizaje profundo con Python!
¿Qué pasaría si pudieras desarrollar una red en minutos
…con sólo unas pocas líneas de Python…
Descubre cómo en mi nuevo Ebook:
Aprendizaje profundo con Python
Cubre proyectos integrales en temas como:
Percepciones multicapas, Redes convolucionales y Redes neuronales recurrentesy más…
Por fin traer el aprendizaje profundo a
Sus propios proyectos
Sáltese los académicos. Sólo los resultados.
Ver lo que hay dentro