AutoML se refiere a las técnicas para descubrir automáticamente el modelo de mejor rendimiento para un determinado conjunto de datos.
Cuando se aplica a las redes neuronales, esto implica tanto el descubrimiento de la arquitectura del modelo como de los hiperparámetros utilizados para entrenar el modelo, generalmente denominados búsqueda de arquitectura neuronal.
AutoKeras es una biblioteca de código abierto para realizar AutoML para modelos de aprendizaje profundo. La búsqueda se realiza utilizando los llamados modelos Keras a través de la API TensorFlow tf.keras.
Proporciona un enfoque simple y eficaz para encontrar automáticamente modelos de alto rendimiento para una amplia gama de tareas de modelización predictiva, incluidos los conjuntos de datos de clasificación y regresión tabulares o los denominados estructurados.
En este tutorial, descubrirá cómo utilizar el AutoKeras para encontrar buenos modelos de redes neuronales para tareas de clasificación y regresión.
Después de completar este tutorial, lo sabrás:
- AutoKeras es una implementación de AutoML para el aprendizaje profundo que utiliza la búsqueda de la arquitectura neural.
- Cómo usar el AutoKeras para encontrar un modelo de alto rendimiento para un conjunto de datos de clasificación binaria.
- Cómo usar el AutoKeras para encontrar un modelo de alto rendimiento para un conjunto de datos de regresión.
Empecemos.
Cómo utilizar los AutoKeras para la clasificación y la regresión
Foto de kanu101, algunos derechos reservados.
Resumen del Tutorial
Este tutorial está dividido en tres partes; son:
- AutoKeras para un aprendizaje profundo
- AutoKeras para la clasificación
- AutoKeras para la regresión
AutoKeras para un aprendizaje profundo
El Aprendizaje Automático de Máquinas, o AutoML para abreviar, se refiere a la búsqueda automática de la mejor combinación de preparación de datos, modelo e hiperparámetros de modelo para un problema de modelado predictivo.
El beneficio del AutoML es que permite a los profesionales del aprendizaje automático abordar rápida y eficazmente las tareas de modelización predictiva con muy poca aportación, por ejemplo, disparar y olvidar.
El Aprendizaje Automático de Máquinas (AutoML) se ha convertido en un tema de investigación muy importante con amplias aplicaciones de técnicas de aprendizaje de máquinas. El objetivo de AutoML es permitir que las personas con conocimientos limitados de aprendizaje automático puedan utilizar fácilmente los modelos de aprendizaje automático.
– Auto-keras: Un eficiente sistema de búsqueda de arquitectura neuronal, 2019.
AutoKeras es una implementación de AutoML para modelos de aprendizaje profundo utilizando la API de Keras, específicamente la API tf.keras proporcionada por TensorFlow 2.
Utiliza un proceso de búsqueda a través de las arquitecturas de redes neuronales para abordar mejor una tarea de modelado, conocida más generalmente como Búsqueda de Arquitectura Neural, o NAS para abreviar.
… hemos desarrollado un sistema de código abierto de AutoML ampliamente adoptado basado en nuestro método propuesto, a saber, Auto-Keras. Es un sistema de código abierto de AutoML, que puede ser descargado e instalado localmente.
– Auto-keras: Un eficiente sistema de búsqueda de arquitectura neuronal, 2019.
En el espíritu de Keras, AutoKeras proporciona una interfaz fácil de usar para diferentes tareas, como la clasificación de imágenes, la clasificación de datos estructurados o la regresión, y más. El usuario sólo tiene que especificar la ubicación de los datos y el número de modelos a probar y se le devuelve un modelo que logra el mejor rendimiento (bajo las restricciones configuradas) en ese conjunto de datos.
Nota: AutoKeras proporciona un modelo TensorFlow 2 Keras (por ejemplo, tf.keras) y no un modelo autónomo Keras. Como tal, la biblioteca asume que tiene instalado Python 3 y TensorFlow 2.1 o superior.
Para instalar AutoKeras, puedes usar Pip, de la siguiente manera:
|
sudo pip instalar autokeras |
Puede confirmar que la instalación se realizó con éxito y comprobar el número de versión como sigue:
Debería ver la salida como la siguiente:
|
Nombre: autokeras Versión: 1.0.1 Resumen: AutoML para un aprendizaje profundo Página web: http://autokeras.com Autor: Análisis de datos en el laboratorio de Texas A&M (DATA), Equipo Keras Correo electrónico del autor: jhfjhfj1@gmail.com Licencia: MIT Ubicación: … Requiere: aprendizaje de la ciencia, empaquetado, pandas, keras-tuner, numpy Requerido por: |
Una vez instalado, puede aplicar AutoKeras para encontrar un buen o gran modelo de red neuronal para su tarea de modelado predictivo.
Vamos a ver dos ejemplos comunes en los que puede querer usar AutoKeras, clasificación y regresión en datos tabulares, los llamados datos estructurados.
AutoKeras para la clasificación
El AutoKeras puede ser usado para descubrir un buen o gran modelo para tareas de clasificación en datos tabulares.
Los datos tabulares son aquellos conjuntos de datos compuestos por filas y columnas, como una tabla o datos como los que se verían en una hoja de cálculo.
En esta sección, desarrollaremos un modelo para el conjunto de datos de clasificación del sonar para clasificar los retornos del sonar como rocas o minas. Este conjunto de datos consiste en 208 filas de datos con 60 características de entrada y una etiqueta de clase de objetivo de 0 (roca) o 1 (mina).
Un modelo ingenuo puede lograr una precisión de clasificación de alrededor del 53,4% mediante la validación cruzada repetida 10 veces, lo que proporciona un límite inferior. Un buen modelo puede alcanzar una precisión de alrededor del 88,2%, lo que proporciona un límite superior.
Puedes aprender más sobre el conjunto de datos aquí:
No es necesario descargar el conjunto de datos; lo descargaremos automáticamente como parte del ejemplo.
Primero, podemos descargar el conjunto de datos y dividirlo en un tren seleccionado al azar y un conjunto de pruebas, manteniendo el 33 por ciento para la prueba y usando el 67 por ciento para el entrenamiento.
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 |
# Cargar el conjunto de datos del sonar de pandas importación read_csv de sklearn.model_selection importación prueba_de_trenes_split de sklearn.preprocesamiento importación LabelEncoder # Cargar conjunto de datos url = «https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv dataframe = read_csv(url, encabezado=Ninguno) imprimir(dataframe.forma) # Dividido en elementos de entrada y salida datos = dataframe.valores X, y = datos[[:, :–1], datos[[:, –1] imprimir(X.forma, y.forma) # Preparación de datos básicos X = X.astype(«Float32) y = LabelEncoder().fit_transform(y) # Separados en trenes y juegos de prueba X_tren, X_test, y_tren, y_test = prueba_de_trenes_split(X, y, tamaño_de_prueba=0.33, estado_aleatorio=1) imprimir(X_tren.forma, X_test.forma, y_tren.forma, y_test.forma) |
Ejecutando el ejemplo primero se descarga el conjunto de datos y se resume la forma, mostrando el número esperado de filas y columnas.
El conjunto de datos se divide entonces en elementos de entrada y salida, y estos elementos se dividen a su vez en conjuntos de datos de tren y de prueba.
|
(208, 61) (208, 60) (208,) (139, 60) (69, 60) (139,) (69,) |
Podemos usar el AutoKeras para descubrir automáticamente un modelo de red neural efectivo para este conjunto de datos.
Esto puede lograrse utilizando la clase StructuredDataClassifier y especificando el número de modelos a buscar. Esto define la búsqueda a realizar.
|
... # Definir la búsqueda busca en = StructuredDataClassifier(max_trials=15) |
Podemos entonces ejecutar la búsqueda usando nuestro conjunto de datos cargado.
|
... # realizar la búsqueda busca en.encajar(x=X_tren, y=y_tren, verboso=0) |
Esto puede tomar unos minutos e informará del progreso de la búsqueda.
A continuación, podemos evaluar el modelo en el conjunto de datos de la prueba para ver cómo se desempeña en los nuevos datos.
|
... # Evaluar el modelo pérdida, acc = busca en.evalúa(X_test, y_test, verboso=0) imprimir(Precisión: %.3f’. % acc) |
Luego usamos el modelo para hacer una predicción para una nueva fila de datos.
|
... # Usar el modelo para hacer una predicción fila = [[0.0200,0.0371,0.0428,0.0207,0.0954,0.0986,0.1539,0.1601,0.3109,0.2111,0.1609,0.1582,0.2238,0.0645,0.0660,0.2273,0.3100,0.2999,0.5078,0.4797,0.5783,0.5071,0.4328,0.5550,0.6711,0.6415,0.7104,0.8080,0.6791,0.3857,0.1307,0.2604,0.5121,0.7547,0.8537,0.8507,0.6692,0.6097,0.4943,0.2744,0.0510,0.2834,0.2825,0.4256,0.2641,0.1386,0.1051,0.1343,0.0383,0.0324,0.0232,0.0027,0.0065,0.0159,0.0072,0.0167,0.0180,0.0084,0.0090,0.0032] X_nuevo = asarray([[fila]).astype(«Float32) yhat = busca en.predecir(X_nuevo) imprimir(«Predicho: %.3f % yhat[[0]) |
Podemos recuperar el modelo final, que es un ejemplo de un modelo de TensorFlow Keras.
|
... # Obtener el modelo de mejor rendimiento modelo = busca en.export_model() |
Podemos entonces resumir la estructura del modelo para ver lo que fue seleccionado.
|
... # Resumir el modelo cargado modelo.resumen() |
Por último, podemos guardar el modelo en un archivo para su uso posterior, que puede ser cargado con la función TensorFlow load_model().
|
... # Guarda el modelo de mejor rendimiento en un archivo modelo.guardar(‘model_sonar.h5’) |
Enlazando todo esto, el ejemplo completo de la aplicación de AutoKeras para encontrar un modelo de red neural eficaz para el conjunto de datos del Sonar 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 |
# Usar autokeras para encontrar un modelo para el conjunto de datos del sonar de numpy importación asarray de pandas importación read_csv de sklearn.model_selection importación prueba_de_trenes_split de sklearn.preprocesamiento importación LabelEncoder de autokeras importación StructuredDataClassifier # Cargar conjunto de datos url = «https://raw.githubusercontent.com/jbrownlee/Datasets/master/sonar.csv dataframe = read_csv(url, encabezado=Ninguno) imprimir(dataframe.forma) # Dividido en elementos de entrada y salida datos = dataframe.valores X, y = datos[[:, :–1], datos[[:, –1] imprimir(X.forma, y.forma) # Preparación de datos básicos X = X.astype(«Float32) y = LabelEncoder().fit_transform(y) # Separados en trenes y juegos de prueba X_tren, X_test, y_tren, y_test = prueba_de_trenes_split(X, y, tamaño_de_prueba=0.33, estado_aleatorio=1) imprimir(X_tren.forma, X_test.forma, y_tren.forma, y_test.forma) # Definir la búsqueda busca en = StructuredDataClassifier(max_trials=15) # realizar la búsqueda busca en.encajar(x=X_tren, y=y_tren, verboso=0) # Evaluar el modelo pérdida, acc = busca en.evalúa(X_test, y_test, verboso=0) imprimir(Precisión: %.3f’. % acc) # Usar el modelo para hacer una predicción fila = [[0.0200,0.0371,0.0428,0.0207,0.0954,0.0986,0.1539,0.1601,0.3109,0.2111,0.1609,0.1582,0.2238,0.0645,0.0660,0.2273,0.3100,0.2999,0.5078,0.4797,0.5783,0.5071,0.4328,0.5550,0.6711,0.6415,0.7104,0.8080,0.6791,0.3857,0.1307,0.2604,0.5121,0.7547,0.8537,0.8507,0.6692,0.6097,0.4943,0.2744,0.0510,0.2834,0.2825,0.4256,0.2641,0.1386,0.1051,0.1343,0.0383,0.0324,0.0232,0.0027,0.0065,0.0159,0.0072,0.0167,0.0180,0.0084,0.0090,0.0032] X_nuevo = asarray([[fila]).astype(«Float32) yhat = busca en.predecir(X_nuevo) imprimir(«Predicho: %.3f % yhat[[0]) # Obtener el modelo de mejor rendimiento modelo = busca en.export_model() # Resumir el modelo cargado modelo.resumen() # Guarda el modelo de mejor rendimiento en un archivo modelo.guardar(‘model_sonar.h5’) |
Ejecutar el ejemplo reportará mucha información de depuración sobre el progreso de la búsqueda.
Los modelos y los resultados se guardan en una carpeta llamada «clasificador_de_datos_estructurados«en su actual directorio de trabajo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
… [Trial complete] [Trial summary]|-identificación de prueba: e8265ad768619fc3b69a85b026f70db6 |-Puntuación: 0,9259259104728699 |-El mejor paso: 0 > Hiperparámetros: | clasificación_cabeza_1/tasa_de_abandono: 0 |-optimizador: adam |-estructurado_de_datos_de_bloqueo_1/densidad_de_bloqueo_1/tasa_de_abandono: 0.0 |-bloque_de_datos_estructurados_1/bloque_densidad_1/capas_numéricas: 2 |-bloque_de_datos_estructurados_1/bloque_densidad_1/unidades_0: 32 |-bloque_de_datos_estructurados_1/bloque_de_defensa_1/unidades_1: 16 |-bloque_de_datos_estructurados_1/bloque_de_defensa_1/unidades_2: 512 |-bloque_de_datos_estructurados_1/bloque_de_densas_1/norma_de_usos: Falso |-bloque_de_datos_estructurados_1/bloque_de_defensa_2/tasa_de_abandono: 0.25 |-…bloque_de_datos_estructurados_1/bloque_densado_2/capas_de_numero: 3 |-bloque_de_datos_estructurados_1/bloque_de_defensa_2/unidades_0: 32 |-bloque_de_datos_estructurados_1/bloque_de_defensa_2/unidades_1: 16 |-bloque_de_datos_estructurados_1/bloque_de_defensa_2/unidades_2: 16 |-bloque_de_datos_estructurados_1/bloque_de_defensa_2/norma_de_uso: Falso |
El modelo de mejor rendimiento se evalúa en el conjunto de datos de la prueba de retenció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, podemos ver que el modelo alcanzó una precisión de clasificación de alrededor del 82,6 por ciento.
A continuación, se informa de la arquitectura del modelo de mejor rendimiento.
Podemos ver un modelo con dos capas ocultas con abandono y activación de ReLU.
|
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 |
Modelo: «modelo» _________________________________________________________________ Capa (tipo) Forma de salida Param # ================================================================= input_1 (InputLayer) [(None, 60)] 0 _________________________________________________________________ categorical_encoding (Catego (None, 60) 0 _________________________________________________________________ denso (Dense) (Ninguno, 256) 15616 _________________________________________________________________ re_lu (ReLU) (Ninguno, 256) 0 _________________________________________________________________ abandono (Dropout) (Ninguno, 256) 0 _________________________________________________________________ denso_1 (Dense) (Ninguno, 512) 131584 _________________________________________________________________ re_lu_1 (ReLU) (Ninguno, 512) 0 _________________________________________________________________ abandono_1 (abandono) (Ninguno, 512) 0 _________________________________________________________________ denso_2 (Dense) (Ninguno, 1) 513 _________________________________________________________________ clasificación_cabeza_1 (Sigmo (Ninguna, 1) 0 ================================================================= Parámetros totales: 147,713 Parámetros entrenables: 147,713 Parámetros no entrenables: 0 _________________________________________________________________ |
AutoKeras para la regresión
Los AutoKeras también pueden ser utilizados para tareas de regresión, es decir, problemas de modelado predictivo donde se predice un valor numérico.
Utilizaremos el conjunto de datos del seguro de automóviles que implica la predicción del pago total de las reclamaciones dado el número total de reclamaciones. El conjunto de datos tiene 63 filas y una variable de entrada y otra de salida.
Un modelo ingenuo puede lograr un error absoluto medio (MAE) de alrededor de 66 utilizando una validación cruzada repetida 10 veces, proporcionando un límite inferior en el rendimiento esperado. Un buen modelo puede lograr un MAE de alrededor de 28, proporcionando un límite superior de rendimiento.
Puedes aprender más sobre este conjunto de datos aquí:
Podemos cargar el conjunto de datos y dividirlo en elementos de entrada y salida y luego entrenar y probar los conjuntos de datos.
El ejemplo completo figura a continuación.
|
# Cargar el conjunto de datos del sonar de pandas importación read_csv de sklearn.model_selection importación prueba_de_trenes_split # Cargar conjunto de datos url = ‘https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv’ dataframe = read_csv(url, encabezado=Ninguno) imprimir(dataframe.forma) # Dividido en elementos de entrada y salida datos = dataframe.valores datos = datos.astype(«Float32) X, y = datos[[:, :–1], datos[[:, –1] imprimir(X.forma, y.forma) # Separados en trenes y juegos de prueba X_tren, X_test, y_tren, y_test = prueba_de_trenes_split(X, y, tamaño_de_prueba=0.33, estado_aleatorio=1) imprimir(X_tren.forma, X_test.forma, y_tren.forma, y_test.forma) |
Al ejecutar el ejemplo se carga el conjunto de datos, se confirma el número de filas y columnas, y luego se divide el conjunto de datos en trenes y conjuntos de pruebas.
|
(63, 2) (63, 1) (63,) (42, 1) (21, 1) (42,) (21,) |
El AutoKeras puede ser aplicado a una tarea de regresión usando la clase StructuredDataRegressor y configurado para el número de modelos a probar.
|
... # Definir la búsqueda busca en = StructuredDataRegressor(max_trials=15, pérdida=‘error_absoluto_medio’.) |
La búsqueda puede entonces ser ejecutada y el mejor modelo guardado, como en el caso de la clasificación.
|
... # Definir la búsqueda busca en = StructuredDataRegressor(max_trials=15, pérdida=‘error_absoluto_medio’.) # realizar la búsqueda busca en.encajar(x=X_tren, y=y_tren, verboso=0) |
Podemos entonces utilizar el modelo de mejor rendimiento y evaluarlo en el conjunto de datos de reserva, hacer una predicción sobre los nuevos datos y resumir su estructura.
|
... # Evaluar el modelo mae, _ = busca en.evalúa(X_test, y_test, verboso=0) imprimir(MAE: %.3f % mae) # Usar el modelo para hacer una predicción X_nuevo = asarray([[[[108]]).astype(«Float32) yhat = busca en.predecir(X_nuevo) imprimir(«Predicho: %.3f % yhat[[0]) # Obtener el modelo de mejor rendimiento modelo = busca en.export_model() # Resumir el modelo cargado modelo.resumen() # Guarda el modelo de mejor rendimiento en un archivo modelo.guardar(‘model_insurance.h5’) |
Enlazando todo esto, el ejemplo completo del uso de AutoKeras para descubrir un modelo de red neural efectivo para el conjunto de datos del seguro de automóviles 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 |
# Usar autokeras para encontrar un modelo para el conjunto de datos del seguro de numpy importación asarray de pandas importación read_csv de sklearn.model_selection importación prueba_de_trenes_split de autokeras importación StructuredDataRegressor # Cargar conjunto de datos url = ‘https://raw.githubusercontent.com/jbrownlee/Datasets/master/auto-insurance.csv’ dataframe = read_csv(url, encabezado=Ninguno) imprimir(dataframe.forma) # Dividido en elementos de entrada y salida datos = dataframe.valores datos = datos.astype(«Float32) X, y = datos[[:, :–1], datos[[:, –1] imprimir(X.forma, y.forma) # Separados en trenes y juegos de prueba X_tren, X_test, y_tren, y_test = prueba_de_trenes_split(X, y, tamaño_de_prueba=0.33, estado_aleatorio=1) imprimir(X_tren.forma, X_test.forma, y_tren.forma, y_test.forma) # Definir la búsqueda busca en = StructuredDataRegressor(max_trials=15, pérdida=‘error_absoluto_medio’.) # realizar la búsqueda busca en.encajar(x=X_tren, y=y_tren, verboso=0) # Evaluar el modelo mae, _ = busca en.evalúa(X_test, y_test, verboso=0) imprimir(MAE: %.3f % mae) # Usar el modelo para hacer una predicción X_nuevo = asarray([[[[108]]).astype(«Float32) yhat = busca en.predecir(X_nuevo) imprimir(«Predicho: %.3f % yhat[[0]) # Obtener el modelo de mejor rendimiento modelo = busca en.export_model() # Resumir el modelo cargado modelo.resumen() # Guarda el modelo de mejor rendimiento en un archivo modelo.guardar(‘model_insurance.h5’) |
Ejecutar el ejemplo reportará mucha información de depuración sobre el progreso de la búsqueda.
Los modelos y los resultados se guardan en una carpeta llamada «estructurada_data_regresiva«en su actual directorio de trabajo.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
… [Trial summary]|-identificación de prueba: ea28b767d13e958c3ace7e54e7cb5a14 |-Puntuación: 108.62509155273438 |-El mejor paso: 0 > Hiperparámetros: |-optimizador: adam |-regresión_de_cabeza_1/ritmo_de_abandono: 0 |-estructurado_de_datos_de_bloqueo_1/densidad_de_bloqueo_1/tasa_de_abandono: 0.0 |-bloque_de_datos_estructurados_1/bloque_densidad_1/capas_numéricas: 2 |-bloque_de_datos_estructurados_1/bloque_de_defensa_1/unidades_0: 16 |-bloque_de_datos_estructurados_1/bloque_de_defensa_1/unidades_1: 1024 |-bloque_de_datos_estructurados_1/bloque_de_defensa_1/unidades_2: 128 |-bloque_de_datos_estructurados_1/bloque_de_densas_1/norma_de_usos: Verdadero |-bloque_de_datos_estructurados_1/bloque_de_defensa_2/tasa_de_abandono: 0.5 |-bloque_de_datos_estructurados_1/bloque_densidad_2/capas_de_numero: 2 |-bloque_de_datos_estructurados_1/bloque_de_defensa_2/unidades_0: 256 |-bloque_de_datos_estructurados_1/bloque_de_defensa_2/unidades_1: 64 |-bloque_de_datos_estructurados_1/bloque_de_defensa_2/unidades_2: 1024 |-bloque_de_datos_estructurados_1/bloque_de_defensa_2/norma_de_uso: Verdadero |
El modelo de mejor rendimiento se evalúa en el conjunto de datos de la prueba de retenció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, podemos ver que el modelo alcanzó un MAE de alrededor de 24.
A continuación, se informa de la arquitectura del modelo de mejor rendimiento.
Podemos ver un modelo con dos capas ocultas con activación ReLU.
|
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 |
Modelo: «modelo» _________________________________________________________________ Capa (tipo) Forma de salida Param # ================================================================= input_1 (InputLayer) [(None, 1)] 0 _________________________________________________________________ categorical_encoding (Catego (None, 1) 0 _________________________________________________________________ denso (Dense) (Ninguno, 64) 128 _________________________________________________________________ re_lu (ReLU) (Ninguno, 64) 0 _________________________________________________________________ denso_1 (Dense) (Ninguno, 512) 33280 _________________________________________________________________ re_lu_1 (ReLU) (Ninguno, 512) 0 _________________________________________________________________ denso_2 (Dense) (Ninguno, 128) 65664 _________________________________________________________________ re_lu_2 (ReLU) (Ninguno, 128) 0 _________________________________________________________________ regression_head_1 (Dense) (Ninguna, 1) 129 ================================================================= Parámetros totales: 99,201 Parámetros entrenables: 99,201 Parámetros no entrenables: 0 _________________________________________________________________ |
Más lecturas
Esta sección proporciona más recursos sobre el tema si desea profundizar en él.
Resumen
En este tutorial, descubriste cómo usar AutoKeras para encontrar buenos modelos de redes neuronales para tareas de clasificación y regresión.
Específicamente, aprendiste:
- AutoKeras es una implementación de AutoML para el aprendizaje profundo que utiliza la búsqueda de la arquitectura neural.
- Cómo usar el AutoKeras para encontrar un modelo de alto rendimiento para un conjunto de datos de clasificación binaria.
- Cómo usar el AutoKeras para encontrar un modelo de alto rendimiento para un conjunto de datos de regresión.
¿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