Keras - Guía rápida
Keras - Introducción
El aprendizaje profundo es uno de los principales subcampos del marco de aprendizaje automático. El aprendizaje automático es el estudio del diseño de algoritmos, inspirado en el modelo del cerebro humano. El aprendizaje profundo se está volviendo más popular en los campos de la ciencia de datos como la robótica, la inteligencia artificial (IA), el reconocimiento de audio y video y el reconocimiento de imágenes. La red neuronal artificial es el núcleo de las metodologías de aprendizaje profundo. El aprendizaje profundo es compatible con varias bibliotecas como Theano, TensorFlow, Caffe, Mxnet, etc., Keras es una de las bibliotecas de Python más potentes y fáciles de usar, que se basa en bibliotecas populares de aprendizaje profundo como TensorFlow, Theano, etc. , para crear modelos de aprendizaje profundo.
Descripción general de Keras
Keras se ejecuta sobre bibliotecas de máquinas de código abierto como TensorFlow, Theano o Cognitive Toolkit (CNTK). Theano es una biblioteca de Python utilizada para tareas de cálculo numérico rápido. TensorFlow es la biblioteca matemática simbólica más famosa utilizada para crear redes neuronales y modelos de aprendizaje profundo. TensorFlow es muy flexible y el beneficio principal es la computación distribuida. CNTK es un marco de aprendizaje profundo desarrollado por Microsoft. Utiliza bibliotecas como Python, C #, C ++ o kits de herramientas de aprendizaje automático independientes. Theano y TensorFlow son bibliotecas muy poderosas pero difíciles de entender para crear redes neuronales.
Keras se basa en una estructura mínima que proporciona una forma limpia y sencilla de crear modelos de aprendizaje profundo basados en TensorFlow o Theano. Keras está diseñado para definir rápidamente modelos de aprendizaje profundo. Bueno, Keras es una opción óptima para aplicaciones de aprendizaje profundo.
Caracteristicas
Keras aprovecha varias técnicas de optimización para hacer que la API de red neuronal de alto nivel sea más fácil y más eficiente. Admite las siguientes funciones:
API consistente, simple y extensible.
Estructura mínima: fácil de lograr el resultado sin lujos.
Es compatible con múltiples plataformas y backends.
Es un marco fácil de usar que se ejecuta tanto en CPU como en GPU.
Gran escalabilidad de la computación.
Beneficios
Keras es un marco muy potente y dinámico y ofrece las siguientes ventajas:
Mayor apoyo de la comunidad.
Fácil de probar.
Las redes neuronales de Keras están escritas en Python, lo que simplifica las cosas.
Keras admite redes convolucionales y recurrentes.
Los modelos de aprendizaje profundo son componentes discretos, por lo que puede combinarlos de muchas formas.
Keras - Instalación
Este capítulo explica cómo instalar Keras en su máquina. Antes de pasar a la instalación, repasemos los requisitos básicos de Keras.
Prerrequisitos
Debe cumplir con los siguientes requisitos:
- Cualquier tipo de sistema operativo (Windows, Linux o Mac)
- Python versión 3.5 o superior.
Pitón
Keras es una biblioteca de redes neuronales basada en Python, por lo que Python debe estar instalado en su máquina. Si python está instalado correctamente en su máquina, abra su terminal y escriba python, podría ver la respuesta similar a la que se especifica a continuación,
Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18)
[MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
A partir de ahora, la última versión es '3.7.2'. Si Python no está instalado, visite el enlace oficial de Python - www.python.org y descargue la última versión basada en su sistema operativo e instálela inmediatamente en su sistema.
Pasos de instalación de Keras
La instalación de Keras es bastante sencilla. Siga los pasos a continuación para instalar correctamente Keras en su sistema.
Paso 1: crear un entorno virtual
Virtualenvse utiliza para administrar paquetes de Python para diferentes proyectos. Esto será útil para evitar romper los paquetes instalados en los otros entornos. Por lo tanto, siempre se recomienda utilizar un entorno virtual al desarrollar aplicaciones Python.
Linux/Mac OS
Usuarios de Linux o Mac OS, vaya al directorio raíz de su proyecto y escriba el siguiente comando para crear un entorno virtual,
python3 -m venv kerasenv
Después de ejecutar el comando anterior, se crea el directorio "kerasenv" con bin,lib and include folders en su ubicación de instalación.
Windows
El usuario de Windows puede usar el siguiente comando,
py -m venv keras
Paso 2: activa el medio ambiente
Este paso configurará los ejecutables de python y pip en su ruta de shell.
Linux/Mac OS
Ahora hemos creado un entorno virtual llamado "kerasvenv". Vaya a la carpeta y escriba el siguiente comando,
$ cd kerasvenv kerasvenv $ source bin/activate
Windows
Los usuarios de Windows se mueven dentro de la carpeta "kerasenv" y escriben el siguiente comando,
.\env\Scripts\activate
Paso 3: bibliotecas de Python
Keras depende de las siguientes bibliotecas de Python.
- Numpy
- Pandas
- Scikit-learn
- Matplotlib
- Scipy
- Seaborn
Con suerte, ha instalado todas las bibliotecas anteriores en su sistema. Si estas bibliotecas no están instaladas, utilice el siguiente comando para instalar una por una.
numpy
pip install numpy
podría ver la siguiente respuesta,
Collecting numpy
Downloading
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/
numpy-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64.
macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB)
|████████████████████████████████| 14.4MB 2.8MB/s
pandas
pip install pandas
Pudimos ver la siguiente respuesta,
Collecting pandas
Downloading
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/
pandas-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64.
macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB)
|████████████████████████████████| 14.4MB 2.8MB/s
matplotlib
pip install matplotlib
Pudimos ver la siguiente respuesta,
Collecting matplotlib
Downloading
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/
matplotlib-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64.
macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB)
|████████████████████████████████| 14.4MB 2.8MB/s
scipy
pip install scipy
Pudimos ver la siguiente respuesta,
Collecting scipy
Downloading
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8
/scipy-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64.
macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB)
|████████████████████████████████| 14.4MB 2.8MB/s
scikit-learn
Es una biblioteca de aprendizaje automático de código abierto. Se utiliza para algoritmos de clasificación, regresión y agrupación. Antes de pasar a la instalación, se requiere lo siguiente:
- Python versión 3.5 o superior
- NumPy versión 1.11.0 o superior
- SciPy versión 0.17.0 o superior
- joblib 0.11 o superior.
Ahora, instalamos scikit-learn usando el siguiente comando:
pip install -U scikit-learn
Seaborn
Seaborn es una biblioteca increíble que le permite visualizar fácilmente sus datos. Utilice el siguiente comando para instalar:
pip pip install seaborninstall -U scikit-learn
Puede ver un mensaje similar al que se especifica a continuación:
Collecting seaborn
Downloading
https://files.pythonhosted.org/packages/a8/76/220ba4420459d9c4c9c9587c6ce607bf56c25b3d3d2de62056efe482dadc
/seaborn-0.9.0-py3-none-any.whl (208kB) 100%
|████████████████████████████████| 215kB 4.0MB/s
Requirement already satisfied: numpy> = 1.9.3 in
./lib/python3.7/site-packages (from seaborn) (1.17.0)
Collecting pandas> = 0.15.2 (from seaborn)
Downloading
https://files.pythonhosted.org/packages/39/b7/441375a152f3f9929ff8bc2915218ff1a063a59d7137ae0546db616749f9/
pandas-0.25.0-cp37-cp37m-macosx_10_9_x86_64.
macosx_10_10_x86_64.whl (10.1MB) 100%
|████████████████████████████████| 10.1MB 1.8MB/s
Requirement already satisfied: scipy>=0.14.0 in
./lib/python3.7/site-packages (from seaborn) (1.3.0)
Collecting matplotlib> = 1.4.3 (from seaborn)
Downloading
https://files.pythonhosted.org/packages/c3/8b/af9e0984f
5c0df06d3fab0bf396eb09cbf05f8452de4e9502b182f59c33b/
matplotlib-3.1.1-cp37-cp37m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64
.macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 100%
|████████████████████████████████| 14.4MB 1.4MB/s
......................................
......................................
Successfully installed cycler-0.10.0 kiwisolver-1.1.0
matplotlib-3.1.1 pandas-0.25.0 pyparsing-2.4.2
python-dateutil-2.8.0 pytz-2019.2 seaborn-0.9.0
Instalación de Keras usando Python
A partir de ahora, hemos completado los requisitos básicos para la instalación de Kera. Ahora, instale Keras usando el mismo procedimiento que se especifica a continuación:
pip install keras
Salir del entorno virtual
Después de finalizar todos los cambios en su proyecto, simplemente ejecute el siguiente comando para salir del entorno:
deactivate
Nube Anaconda
Creemos que ha instalado anaconda cloud en su máquina. Si anaconda no está instalado, visite el enlace oficial, www.anaconda.com/distribution y elija descargar según su sistema operativo.
Crea un nuevo entorno de conda
Inicie el indicador de anaconda, esto abrirá el entorno base de Anaconda. Creemos un nuevo entorno conda. Este proceso es similar al virtualenv. Escriba el siguiente comando en su terminal conda:
conda create --name PythonCPU
Si lo desea, también puede crear e instalar módulos usando GPU. En este tutorial, seguimos las instrucciones de la CPU.
Activar entorno conda
Para activar el entorno, use el siguiente comando:
activate PythonCPU
Instalar spyder
Spyder es un IDE para ejecutar aplicaciones de Python. Instalemos este IDE en nuestro entorno conda usando el siguiente comando:
conda install spyder
Instalar bibliotecas de Python
Ya conocemos las bibliotecas de Python numpy, pandas, etc., necesarias para keras. Puede instalar todos los módulos utilizando la siguiente sintaxis:
Syntax
conda install -c anaconda <module-name>
Por ejemplo, desea instalar pandas:
conda install -c anaconda pandas
Como el mismo método, inténtelo usted mismo para instalar los módulos restantes.
Instalar Keras
Ahora, todo se ve bien, por lo que puede iniciar la instalación de keras usando el siguiente comando:
conda install -c anaconda keras
Lanzar spyder
Finalmente, inicie spyder en su terminal conda usando el siguiente comando:
spyder
Para asegurarse de que todo se instaló correctamente, importe todos los módulos, agregará todo y si algo salió mal, obtendrá module not found mensaje de error.
Keras - Configuración de backend
Este capítulo explica en detalle las implementaciones de backend de Keras, TensorFlow y Theano. Repasemos cada implementación una por una.
TensorFlow
TensorFlow es una biblioteca de aprendizaje automático de código abierto que se utiliza para tareas computacionales numéricas desarrolladas por Google. Keras es una API de alto nivel construida sobre TensorFlow o Theano. Ya sabemos cómo instalar TensorFlow usando pip.
Si no está instalado, puede instalar usando el siguiente comando:
pip install TensorFlow
Una vez que ejecutamos keras, podríamos ver que el archivo de configuración está ubicado en su directorio de inicio dentro y vamos a .keras / keras.json.
keras.json
{
"image_data_format": "channels_last",
"epsilon": 1e-07, "floatx": "float32", "backend": "tensorflow"
}
Aquí,
image_data_format representan el formato de datos.
epsilonrepresenta una constante numérica. Se usa para evitarDivideByZero error.
floatx representa el tipo de datos predeterminado float32. También puede cambiarlo afloat16 o float64 utilizando set_floatx() método.
image_data_format representan el formato de datos.
Supongamos que, si el archivo no se crea, muévase a la ubicación y cree siguiendo los pasos a continuación:
> cd home
> mkdir .keras
> vi keras.json
Recuerde, debe especificar .keras como su nombre de carpeta y agregar la configuración anterior dentro del archivo keras.json. Podemos realizar algunas operaciones predefinidas para conocer las funciones de backend.
Theano
Theano es una biblioteca de aprendizaje profundo de código abierto que le permite evaluar matrices multidimensionales de manera efectiva. Podemos instalar fácilmente usando el siguiente comando:
pip install theano
De forma predeterminada, keras usa el backend de TensorFlow. Si desea cambiar la configuración de backend de TensorFlow a Theano, simplemente cambie backend = theano en el archivo keras.json. Se describe a continuación:
keras.json
{
"image_data_format": "channels_last",
"epsilon": 1e-07,
"floatx": "float32",
"backend": "theano"
}
Ahora guarda tu archivo, reinicia tu terminal e inicia keras, tu backend será cambiado.
>>> import keras as k
using theano backend.
Keras: descripción general del aprendizaje profundo
El aprendizaje profundo es un subcampo en evolución del aprendizaje automático. El aprendizaje profundo implica analizar la entrada capa por capa, donde cada capa extrae progresivamente información de nivel superior sobre la entrada.
Tomemos un escenario simple de analizar una imagen. Supongamos que su imagen de entrada está dividida en una cuadrícula rectangular de píxeles. Ahora, la primera capa abstrae los píxeles. La segunda capa comprende los bordes de la imagen. La siguiente capa construye nodos a partir de los bordes. Luego, el siguiente encontraría ramas de los nodos. Finalmente, la capa de salida detectará el objeto completo. Aquí, el proceso de extracción de características va desde la salida de una capa hasta la entrada de la siguiente capa posterior.
Al utilizar este enfoque, podemos procesar una gran cantidad de funciones, lo que hace que el aprendizaje profundo sea una herramienta muy poderosa. Los algoritmos de aprendizaje profundo también son útiles para el análisis de datos no estructurados. Repasemos los conceptos básicos del aprendizaje profundo en este capítulo.
Redes neuronales artificiales
El enfoque más popular y principal del aprendizaje profundo es el uso de una "red neuronal artificial" (ANN). Están inspirados en el modelo del cerebro humano, que es el órgano más complejo de nuestro cuerpo. El cerebro humano está formado por más de 90 mil millones de células diminutas llamadas "neuronas". Las neuronas están interconectadas a través de fibras nerviosas llamadas "axones" y "dendritas". La función principal del axón es transmitir información de una neurona a otra a la que está conectado.
Del mismo modo, la función principal de las dendritas es recibir la información que transmiten los axones de otra neurona a la que están conectadas. Cada neurona procesa una pequeña información y luego pasa el resultado a otra neurona y este proceso continúa. Este es el método básico utilizado por nuestro cerebro humano para procesar una gran cantidad de información como el habla, visual, etc., y extraer información útil de ella.
Basado en este modelo, el psicólogo inventó la primera Red Neural Artificial (ANN). Frank Rosenblatt, en el año de 1958. Las ANN están formadas por múltiples nodos que es similar a las neuronas. Los nodos están estrechamente interconectados y organizados en diferentes capas ocultas. La capa de entrada recibe los datos de entrada y los datos pasan por una o más capas ocultas secuencialmente y finalmente la capa de salida predice algo útil sobre los datos de entrada. Por ejemplo, la entrada puede ser una imagen y la salida puede ser la cosa identificada en la imagen, digamos un "gato".
Una sola neurona (llamada perceptrón en ANN) se puede representar de la siguiente manera:
Aquí,
La entrada múltiple junto con el peso representan dendritas.
La suma de la entrada junto con la función de activación representa las neuronas. Sum en realidad significa que el valor calculado de todas las entradas y la función de activación representan una función, que modifica el Sum valor en 0, 1 o 0 a 1.
La salida real representa el axón y la salida será recibida por la neurona en la siguiente capa.
Entendamos los diferentes tipos de redes neuronales artificiales en esta sección.
Perceptrón multicapa
El perceptrón multicapa es la forma más simple de ANN. Consiste en una sola capa de entrada, una o más capas ocultas y finalmente una capa de salida. Una capa consta de una colección de perceptrón. La capa de entrada es básicamente una o más características de los datos de entrada. Cada capa oculta consta de una o más neuronas y procesa cierto aspecto de la característica y envía la información procesada a la siguiente capa oculta. El proceso de la capa de salida recibe los datos de la última capa oculta y finalmente genera el resultado.
Red neuronal convolucional (CNN)
La red neuronal convolucional es una de las ANN más populares. Es ampliamente utilizado en los campos del reconocimiento de imágenes y video. Se basa en el concepto de convolución, un concepto matemático. Es casi similar al perceptrón multicapa, excepto que contiene una serie de capas de convolución y una capa de agrupación antes de la capa de neuronas ocultas completamente conectadas. Tiene tres capas importantes:
Convolution layer - Es el bloque de construcción principal y realiza tareas computacionales basadas en la función de convolución.
Pooling layer - Se organiza junto a la capa de convolución y se utiliza para reducir el tamaño de las entradas eliminando información innecesaria para que el cálculo se pueda realizar más rápido.
Fully connected layer - Está organizado junto a una serie de convolución y capa de agrupación y clasifica la entrada en varias categorías.
Una CNN simple se puede representar de la siguiente manera:
Aquí,
Se utilizan 2 series de capas de convolución y agrupación, que reciben y procesan la entrada (por ejemplo, imagen).
Se utiliza una única capa completamente conectada y se utiliza para generar los datos (por ejemplo, clasificación de la imagen)
Red neuronal recurrente (RNN)
Las redes neuronales recurrentes (RNN) son útiles para abordar la falla en otros modelos de ANN. Bueno, la mayoría de la ANN no recuerda los pasos de situaciones anteriores y aprendió a tomar decisiones basadas en el contexto en el entrenamiento. Mientras tanto, RNN almacena la información pasada y todas sus decisiones se toman de lo que ha aprendido del pasado.
Este enfoque es principalmente útil en la clasificación de imágenes. A veces, es posible que debamos mirar hacia el futuro para arreglar el pasado. En este caso, la RNN bidireccional es útil para aprender del pasado y predecir el futuro. Por ejemplo, tenemos muestras escritas a mano en múltiples entradas. Supongamos que tenemos confusión en una entrada y luego necesitamos volver a comprobar otras entradas para reconocer el contexto correcto que toma la decisión del pasado.
Flujo de trabajo de ANN
Primero entendamos las diferentes fases del aprendizaje profundo y luego, aprendamos cómo Keras ayuda en el proceso de aprendizaje profundo.
Recopile los datos requeridos
El aprendizaje profundo requiere muchos datos de entrada para aprender y predecir con éxito el resultado. Entonces, primero recopile la mayor cantidad de datos posible.
Analizar datos
Analice los datos y adquiera una buena comprensión de los datos. Se requiere una mejor comprensión de los datos para seleccionar el algoritmo ANN correcto.
Elija un algoritmo (modelo)
Elija un algoritmo que se adapte mejor al tipo de proceso de aprendizaje (por ejemplo, clasificación de imágenes, procesamiento de texto, etc.) y los datos de entrada disponibles. El algoritmo está representado porModelen Keras. El algoritmo incluye una o más capas. Cada capa en ANN se puede representar porKeras Layer en Keras.
Prepare data - Procesar, filtrar y seleccionar solo la información requerida de los datos.
Split data- Divida los datos en conjuntos de datos de prueba y entrenamiento. Los datos de prueba se utilizarán para evaluar la predicción del algoritmo / modelo (una vez que la máquina aprenda) y para verificar la eficiencia del proceso de aprendizaje.
Compile the model- Compilar el algoritmo / modelo, de modo que se pueda utilizar más para aprender mediante el entrenamiento y finalmente hacer la predicción. Este paso nos obliga a elegir la función de pérdida y el Optimizador. La función de pérdida y el Optimizador se utilizan en la fase de aprendizaje para encontrar el error (desviación de la salida real) y realizar la optimización para que el error se minimice.
Fit the model - El proceso de aprendizaje real se realizará en esta fase utilizando el conjunto de datos de entrenamiento.
Predict result for unknown value - Predecir la salida de los datos de entrada desconocidos (distintos de los datos de prueba y entrenamiento existentes)
Evaluate model - Evalúe el modelo prediciendo la salida de los datos de prueba y comparando la predicción con el resultado real de los datos de prueba.
Freeze, Modify or choose new algorithm- Verificar si la evaluación del modelo es exitosa. Si es así, guarde el algoritmo para fines de predicción futura. Si no es así, modifique o elija un nuevo algoritmo / modelo y, finalmente, entrene, prediga y evalúe el modelo nuevamente. Repita el proceso hasta encontrar el mejor algoritmo (modelo).
Los pasos anteriores se pueden representar utilizando el siguiente diagrama de flujo:
Keras - Aprendizaje profundo
Keras proporciona un marco completo para crear cualquier tipo de redes neuronales. Keras es innovador y muy fácil de aprender. Admite una red neuronal simple a un modelo de red neuronal muy grande y complejo. Entendamos la arquitectura del marco de Keras y cómo Keras ayuda en el aprendizaje profundo en este capítulo.
Arquitectura de Keras
La API de Keras se puede dividir en tres categorías principales:
- Model
- Layer
- Módulos centrales
En Keras, cada RNA está representada por Keras Models. A su vez, cada modelo de Keras es una composición deKeras Layers y representa capas ANN como entrada, capa oculta, capas de salida, capa de convolución, capa de agrupación, etc., modelo de Keras y acceso a la capa Keras modules para la función de activación, función de pérdida, función de regularización, etc. Utilizando el modelo Keras, Keras Layer y los módulos Keras, cualquier algoritmo ANN (CNN, RNN, etc.,) se puede representar de manera simple y eficiente.
El siguiente diagrama muestra la relación entre el modelo, la capa y los módulos centrales:
Veamos la descripción general de los modelos Keras, capas Keras y módulos Keras.
Modelo
Los modelos Keras son de dos tipos, como se menciona a continuación:
Sequential Model- El modelo secuencial es básicamente una composición lineal de capas de Keras. El modelo secuencial es sencillo, mínimo y tiene la capacidad de representar casi todas las redes neuronales disponibles.
Un modelo secuencial simple es el siguiente:
from keras.models import Sequential
from keras.layers import Dense, Activation
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,)))
Dónde,
Line 1 importaciones Sequential modelo de los modelos Keras
Line 2 importaciones Dense capa y Activation módulo
Line 4 crear un nuevo modelo secuencial usando Sequential API
Line 5 agrega una capa densa (API densa) con relu función de activación (usando el módulo de activación).
Sequential modelo expone Modelclass para crear modelos personalizados también. Podemos utilizar el concepto de subclasificación para crear nuestro propio modelo complejo.
Functional API - La API funcional se utiliza básicamente para crear modelos complejos.
Capa
Cada capa de Keras en el modelo de Keras representa la capa correspondiente (capa de entrada, capa oculta y capa de salida) en el modelo de red neuronal propuesto. Keras proporciona muchas capas preconstruidas para que cualquier red neuronal compleja se pueda crear fácilmente. Algunas de las capas importantes de Keras se especifican a continuación,
- Capas centrales
- Capas de convolución
- Capas de agrupación
- Capas recurrentes
Un código Python simple para representar un modelo de red neuronal usando sequential El modelo es el siguiente:
from keras.models import Sequential
from keras.layers import Dense, Activation, Dropout model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,)))
model.add(Dropout(0.2))
model.add(Dense(512, activation = 'relu')) model.add(Dropout(0.2))
model.add(Dense(num_classes, activation = 'softmax'))
Dónde,
Line 1 importaciones Sequential modelo de los modelos Keras
Line 2 importaciones Dense capa y Activation módulo
Line 4 crear un nuevo modelo secuencial usando Sequential API
Line 5 agrega una capa densa (API densa) con relu función de activación (usando el módulo de activación).
Line 6 agrega una capa de abandono (API de abandono) para manejar el ajuste excesivo.
Line 7 agrega otra capa densa (API densa) con relu función de activación (usando el módulo de activación).
Line 8 agrega otra capa de abandono (API de abandono) para manejar el ajuste excesivo.
Line 9 agrega una capa densa final (API densa) con softmax función de activación (usando el módulo de activación).
Keras también ofrece opciones para crear nuestras propias capas personalizadas. La capa personalizada se puede crear subclasificando elKeras.Layer class y es similar a la subclasificación de modelos de Keras.
Módulos centrales
Keras también proporciona muchas funciones integradas relacionadas con la red neuronal para crear correctamente el modelo de Keras y las capas de Keras. Algunas de las funciones son las siguientes:
Activations module - La función de activación es un concepto importante en ANN y los módulos de activación proporcionan muchas funciones de activación como softmax, relu, etc.,
Loss module - El módulo de pérdida proporciona funciones de pérdida como mean_squared_error, mean_absolute_error, poisson, etc.
Optimizer module - El módulo optimizador proporciona una función optimizadora como adam, sgd, etc.,
Regularizers - El módulo regularizador proporciona funciones como regularizador L1, regularizador L2, etc.
Aprendamos los módulos de Keras en detalle en el próximo capítulo.
Keras - Módulos
Como aprendimos anteriormente, los módulos de Keras contienen clases, funciones y variables predefinidas que son útiles para el algoritmo de aprendizaje profundo. Aprendamos los módulos proporcionados por Keras en este capítulo.
Módulos disponibles
Veamos primero la lista de módulos disponibles en Keras.
Initializers- Proporciona una lista de funciones de inicializadores. Podemos aprenderlo en detalle en el capítulo de capas de Keras . durante la fase de creación de modelos de aprendizaje automático.
Regularizers- Proporciona una lista de funciones de regularizadores. Podemos aprenderlo en detalle en el capítulo Capas de Keras .
Constraints- Proporciona una función de lista de restricciones. Podemos aprenderlo en detalle en el capítulo Capas de Keras .
Activations- Proporciona una lista de funciones de activador. Podemos aprenderlo en detalle en el capítulo Capas de Keras .
Losses- Proporciona una lista de funciones de pérdida. Podemos aprenderlo en detalle en el capítulo Entrenamiento de modelos .
Metrics- Proporciona una lista de funciones de métricas. Podemos aprenderlo en detalle en el capítulo Entrenamiento de modelos .
Optimizers- Proporciona una lista de funciones optimizadoras. Podemos aprenderlo en detalle en el capítulo Entrenamiento de modelos .
Callback- Proporciona una lista de funciones de devolución de llamada. Podemos usarlo durante el proceso de entrenamiento para imprimir los datos intermedios, así como para detener el entrenamiento en sí (EarlyStopping método) basado en alguna condición.
Text processing- Proporciona funciones para convertir texto en una matriz NumPy adecuada para el aprendizaje automático. Podemos usarlo en la fase de preparación de datos del aprendizaje automático.
Image processing- Proporciona funciones para convertir imágenes en una matriz NumPy adecuada para el aprendizaje automático. Podemos usarlo en la fase de preparación de datos del aprendizaje automático.
Sequence processing- Proporciona funciones para generar datos basados en el tiempo a partir de los datos de entrada dados. Podemos usarlo en la fase de preparación de datos del aprendizaje automático.
Backend- Proporciona la función de la biblioteca de backend como TensorFlow y Theano .
Utilities - Proporciona muchas funciones útiles en el aprendizaje profundo.
Dejanos ver backend módulo y utils modelo en este capítulo.
módulo de backend
backend modulese utiliza para las operaciones de backend de keras. De forma predeterminada, keras se ejecuta sobre el backend de TensorFlow. Si lo desea, puede cambiar a otros backends como Theano o CNTK. La configuración de backend defualt se define dentro de su directorio raíz en el archivo .keras / keras.json.
El módulo backend de Keras se puede importar usando el siguiente código
>>> from keras import backend as k
Si usamos TensorFlow backend predeterminado , la siguiente función devuelve información basada en TensorFlow como se especifica a continuación:
>>> k.backend()
'tensorflow'
>>> k.epsilon()
1e-07
>>> k.image_data_format()
'channels_last'
>>> k.floatx()
'float32'
Entendamos brevemente algunas de las funciones de backend importantes utilizadas para el análisis de datos:
get_uid ()
Es el identificador del gráfico predeterminado. Se define a continuación:
>>> k.get_uid(prefix='')
1
>>> k.get_uid(prefix='') 2
reset_uids
Se utiliza restablece el valor de uid.
>>> k.reset_uids()
Ahora, vuelva a ejecutar get_uid () . Esto se restablecerá y volverá a cambiar a 1.
>>> k.get_uid(prefix='')
1
marcador de posición
Se utiliza instancia un tensor de marcador de posición. A continuación se muestra un marcador de posición simple para mantener la forma 3D:
>>> data = k.placeholder(shape = (1,3,3))
>>> data
<tf.Tensor 'Placeholder_9:0' shape = (1, 3, 3) dtype = float32>
If you use int_shape(), it will show the shape.
>>> k.int_shape(data) (1, 3, 3)
punto
Se utiliza para multiplicar dos tensores. Considere que ayb son dos tensores yc será el resultado de multiplicar ab. Suponga que una forma es (4,2) y la forma b es (2,3). Se define a continuación,
>>> a = k.placeholder(shape = (4,2))
>>> b = k.placeholder(shape = (2,3))
>>> c = k.dot(a,b)
>>> c
<tf.Tensor 'MatMul_3:0' shape = (4, 3) dtype = float32>
>>>
unos
Se usa para inicializar todo como one valor.
>>> res = k.ones(shape = (2,2))
#print the value
>>> k.eval(res)
array([[1., 1.], [1., 1.]], dtype = float32)
batch_dot
Se utiliza para realizar el producto de dos datos en lotes. La dimensión de entrada debe ser 2 o superior. Se muestra a continuación:
>>> a_batch = k.ones(shape = (2,3))
>>> b_batch = k.ones(shape = (3,2))
>>> c_batch = k.batch_dot(a_batch,b_batch)
>>> c_batch
<tf.Tensor 'ExpandDims:0' shape = (2, 1) dtype = float32>
variable
Se utiliza para inicializar una variable. Realicemos una operación de transposición simple en esta variable.
>>> data = k.variable([[10,20,30,40],[50,60,70,80]])
#variable initialized here
>>> result = k.transpose(data)
>>> print(result)
Tensor("transpose_6:0", shape = (4, 2), dtype = float32)
>>> print(k.eval(result))
[[10. 50.]
[20. 60.]
[30. 70.]
[40. 80.]]
Si desea acceder desde numpy -
>>> data = np.array([[10,20,30,40],[50,60,70,80]])
>>> print(np.transpose(data))
[[10 50]
[20 60]
[30 70]
[40 80]]
>>> res = k.variable(value = data)
>>> print(res)
<tf.Variable 'Variable_7:0' shape = (2, 4) dtype = float32_ref>
is_sparse (tensor)
Se utiliza para comprobar si el tensor es escaso o no.
>>> a = k.placeholder((2, 2), sparse=True)
>>> print(a) SparseTensor(indices =
Tensor("Placeholder_8:0",
shape = (?, 2), dtype = int64),
values = Tensor("Placeholder_7:0", shape = (?,),
dtype = float32), dense_shape = Tensor("Const:0", shape = (2,), dtype = int64))
>>> print(k.is_sparse(a)) True
to_dense ()
Se utiliza para convertir escaso en denso.
>>> b = k.to_dense(a)
>>> print(b) Tensor("SparseToDense:0", shape = (2, 2), dtype = float32)
>>> print(k.is_sparse(b)) False
variable_uniforme_aleatoria
Se usa para inicializar usando uniform distribution concepto.
k.random_uniform_variable(shape, mean, scale)
Aquí,
shape - denota las filas y columnas en formato de tuplas.
mean - media de distribución uniforme.
scale - desviación estándar de distribución uniforme.
Echemos un vistazo al uso de ejemplo a continuación:
>>> a = k.random_uniform_variable(shape = (2, 3), low=0, high = 1)
>>> b = k. random_uniform_variable(shape = (3,2), low = 0, high = 1)
>>> c = k.dot(a, b)
>>> k.int_shape(c)
(2, 2)
módulo utils
utilsproporciona una función de utilidades útiles para el aprendizaje profundo. Algunos de los métodos proporcionados porutils módulo es el siguiente:
HDF5Matrix
Se utiliza para representar los datos de entrada en formato HDF5.
from keras.utils import HDF5Matrix data = HDF5Matrix('data.hdf5', 'data')
to_categorical
Se utiliza para convertir el vector de clase en una matriz de clase binaria.
>>> from keras.utils import to_categorical
>>> labels = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> to_categorical(labels)
array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 1., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 1., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 1., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]], dtype = float32)
>>> from keras.utils import normalize
>>> normalize([1, 2, 3, 4, 5])
array([[0.13483997, 0.26967994, 0.40451992, 0.53935989, 0.67419986]])
print_summary
Se utiliza para imprimir el resumen del modelo.
from keras.utils import print_summary print_summary(model)
plot_model
Se utiliza para crear la representación del modelo en formato de puntos y guardarla en un archivo.
from keras.utils import plot_model
plot_model(model,to_file = 'image.png')
Esta plot_model generará una imagen para comprender el desempeño del modelo.
Keras - Capas
Como se aprendió anteriormente, las capas de Keras son el componente principal de los modelos de Keras. Cada capa recibe información de entrada, realiza algunos cálculos y finalmente genera la información transformada. La salida de una capa fluirá a la siguiente capa como entrada. Aprendamos todos los detalles sobre las capas en este capítulo.
Introducción
Una capa de Keras requiere shape of the input (input_shape) comprender la estructura de los datos de entrada, initializerpara establecer el peso de cada entrada y finalmente los activadores para transformar la salida para que no sea lineal. En el medio, las restricciones restringen y especifican el rango en el que el peso de los datos de entrada que se generarán y el regularizador tratará de optimizar la capa (y el modelo) aplicando dinámicamente las penalizaciones en los pesos durante el proceso de optimización.
Para resumir, la capa de Keras requiere detalles mínimos por debajo para crear una capa completa.
- Forma de los datos de entrada
- Número de neuronas / unidades en la capa
- Initializers
- Regularizers
- Constraints
- Activations
Entendamos el concepto básico en el próximo capítulo. Antes de comprender el concepto básico, creemos una capa de Keras simple utilizando la API de modelo secuencial para tener una idea de cómo funcionan el modelo y la capa de Keras.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
from keras import regularizers
from keras import constraints
model = Sequential()
model.add(Dense(32, input_shape=(16,), kernel_initializer = 'he_uniform',
kernel_regularizer = None, kernel_constraint = 'MaxNorm', activation = 'relu'))
model.add(Dense(16, activation = 'relu'))
model.add(Dense(8))
dónde,
Line 1-5 importa los módulos necesarios.
Line 7 crea un nuevo modelo usando API secuencial.
Line 9 crea un nuevo Dense capa y agréguela al modelo. Densees una capa de nivel de entrada proporcionada por Keras, que acepta el número de neuronas o unidades (32) como parámetro requerido. Si la capa es la primera capa, entonces debemos proporcionarInput Shape, (16,)también. De lo contrario, la salida de la capa anterior se utilizará como entrada de la siguiente capa. Todos los demás parámetros son opcionales.
El primer parámetro representa el número de unidades (neuronas).
input_shape representar la forma de los datos de entrada.
kernel_initializer representan el inicializador que se utilizará. he_uniform la función se establece como valor.
kernel_regularizer representar regularizerpara ser utilizado. Ninguno se establece como valor.
kernel_constraint representan la restricción que se utilizará. MaxNorm la función se establece como valor.
activationrepresentan la activación que se utilizará. La función relu se establece como valor.
Line 10 crea segundo Dense capa con 16 unidades y conjunto relu como función de activación.
Line 11 crea una capa densa final con 8 unidades.
Concepto básico de capas
Entendamos el concepto básico de capa y cómo Keras apoya cada concepto.
Forma de entrada
En el aprendizaje automático, todo tipo de datos de entrada como texto, imágenes o videos se convertirán primero en una matriz de números y luego se incorporarán al algoritmo. Los números de entrada pueden ser una matriz unidimensional, una matriz bidimensional (matriz) o una matriz multidimensional. Podemos especificar la información dimensional usandoshape, una tupla de números enteros. Por ejemplo,(4,2) representar una matriz con cuatro filas y dos columnas.
>>> import numpy as np
>>> shape = (4, 2)
>>> input = np.zeros(shape)
>>> print(input)
[
[0. 0.]
[0. 0.]
[0. 0.]
[0. 0.]
]
>>>
Similar, (3,4,2) matriz tridimensional que tiene tres colecciones de matriz de 4x2 (dos filas y cuatro columnas).
>>> import numpy as np
>>> shape = (3, 4, 2)
>>> input = np.zeros(shape)
>>> print(input)
[
[[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
[[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
[[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
]
>>>
Para crear la primera capa del modelo (o capa de entrada del modelo), se debe especificar la forma de los datos de entrada.
Inicializadores
En Machine Learning, se asignará peso a todos los datos de entrada. InitializersEl módulo proporciona diferentes funciones para establecer estos pesos iniciales. Algunos de losKeras Initializer función son las siguientes:
Ceros
Genera 0 para todos los datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Zeros()
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Dónde, kernel_initializer representan el inicializador del kernel del modelo.
Unos
Genera 1 para todos los datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Ones()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Constante
Genera un valor constante (digamos, 5) especificado por el usuario para todos los datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Constant(value = 0) model.add(
Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)
dónde, value representar el valor constante
AleatorioNormal
Genera valor utilizando la distribución normal de datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.RandomNormal(mean=0.0,
stddev = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
dónde,
mean representar la media de los valores aleatorios para generar
stddev representar la desviación estándar de los valores aleatorios para generar
seed representar los valores para generar un número aleatorio
AleatorioUniforme
Genera valor mediante la distribución uniforme de los datos de entrada.
from keras import initializers
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
dónde,
minval representar el límite inferior de los valores aleatorios para generar
maxval representar el límite superior de los valores aleatorios para generar
TruncatedNormal
Genera valor utilizando una distribución normal truncada de datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.TruncatedNormal(mean = 0.0, stddev = 0.05, seed = None
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
VarianceScaling
Genera un valor basado en la forma de entrada y la forma de salida de la capa junto con la escala especificada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.VarianceScaling(
scale = 1.0, mode = 'fan_in', distribution = 'normal', seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
skernel_initializer = my_init))
dónde,
scale representar el factor de escala
mode representar a cualquiera de fan_in, fan_out y fan_avg valores
distribution representar cualquiera de normal o uniform
VarianceScaling
Encuentra el stddev valor para la distribución normal usando la fórmula siguiente y luego encuentre los pesos usando la distribución normal,
stddev = sqrt(scale / n)
dónde n representar,
número de unidades de entrada para mode = fan_in
número de unidades de salida para mode = fan_out
número medio de unidades de entrada y salida para mode = fan_avg
De manera similar, encuentra el límite para la distribución uniforme usando la siguiente fórmula y luego encuentra los pesos usando la distribución uniforme,
limit = sqrt(3 * scale / n)
lecun_normal
Genera valor usando la distribución normal de lecun de datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Encuentra el stddev usando la fórmula siguiente y luego aplique la distribución normal
stddev = sqrt(1 / fan_in)
dónde, fan_in representan el número de unidades de entrada.
lecun_uniform
Genera valor mediante la distribución uniforme de lecun de los datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.lecun_uniform(seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Encuentra el limit usando la fórmula siguiente y luego aplique una distribución uniforme
limit = sqrt(3 / fan_in)
dónde,
fan_in representa el número de unidades de entrada
fan_out representa el número de unidades de salida
glorot_normal
Genera valor utilizando la distribución normal de glorot de datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.glorot_normal(seed=None) model.add(
Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)
Encuentra el stddev usando la fórmula siguiente y luego aplique la distribución normal
stddev = sqrt(2 / (fan_in + fan_out))
dónde,
fan_in representa el número de unidades de entrada
fan_out representa el número de unidades de salida
glorot_uniform
Genera valor mediante la distribución uniforme Glorot de los datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.glorot_uniform(seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Encuentra el limit usando la fórmula siguiente y luego aplique una distribución uniforme
limit = sqrt(6 / (fan_in + fan_out))
dónde,
fan_in representan el número de unidades de entrada.
fan_out representa el número de unidades de salida
él_normal
Genera valor utilizando la distribución normal de datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Encuentra el stddev usando la siguiente fórmula y luego aplica la distribución normal.
stddev = sqrt(2 / fan_in)
dónde, fan_in representan el número de unidades de entrada.
él_uniforme
Genera valor utilizando la distribución uniforme de los datos de entrada.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.he_normal(seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
Encuentra el limit usando la fórmula siguiente y luego aplique una distribución uniforme.
limit = sqrt(6 / fan_in)
dónde, fan_in representan el número de unidades de entrada.
Ortogonal
Genera una matriz ortogonal aleatoria.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Orthogonal(gain = 1.0, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init))
dónde, gain representan el factor de multiplicación de la matriz.
Identidad
Genera matriz de identidad.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Identity(gain = 1.0) model.add(
Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)
Restricciones
En el aprendizaje automático, se establecerá una restricción en el parámetro (peso) durante la fase de optimización. <> El módulo de restricciones proporciona diferentes funciones para establecer la restricción en la capa. Algunas de las funciones de restricción son las siguientes.
NonNeg
Restringe los pesos para que no sean negativos.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import initializers
my_init = initializers.Identity(gain = 1.0) model.add(
Dense(512, activation = 'relu', input_shape = (784,),
kernel_initializer = my_init)
)
dónde, kernel_constraint representan la restricción que se utilizará en la capa.
UnitNorm
Restringe los pesos para que sean la norma unitaria.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import constraints
my_constrain = constraints.UnitNorm(axis = 0)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_constraint = my_constrain))
MaxNorm
Restringe el peso a la norma menor o igual al valor dado.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import constraints
my_constrain = constraints.MaxNorm(max_value = 2, axis = 0)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_constraint = my_constrain))
dónde,
max_value representar el límite superior
El eje representa la dimensión en la que se aplicará la restricción. Por ejemplo, en Shape (2, 3, 4) el eje 0 indica la primera dimensión, 1 indica la segunda dimensión y 2 indica la tercera dimensión
MinMaxNorm
Restringe los pesos para que sean la norma entre los valores mínimos y máximos especificados.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import constraints
my_constrain = constraints.MinMaxNorm(min_value = 0.0, max_value = 1.0, rate = 1.0, axis = 0)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_constraint = my_constrain))
dónde, rate representan la tasa a la que se aplica la restricción de peso.
Regularizadores
En el aprendizaje automático, los regularizadores se utilizan en la fase de optimización. Aplica algunas penalizaciones en el parámetro de capa durante la optimización. El módulo de regularización de Keras proporciona las siguientes funciones para establecer penalizaciones en la capa. La regularización se aplica solo por capa.
Regularizador L1
Proporciona regularización basada en L1.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import regularizers
my_regularizer = regularizers.l1(0.)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_regularizer = my_regularizer))
dónde, kernel_regularizer representan la tasa a la que se aplica la restricción de peso.
Regularizador L2
Proporciona regularización basada en L2.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import regularizers
my_regularizer = regularizers.l2(0.)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_regularizer = my_regularizer))
Regularizador L1 y L2
Proporciona regularización basada en L1 y L2.
from keras.models import Sequential
from keras.layers import Activation, Dense
from keras import regularizers
my_regularizer = regularizers.l2(0.)
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,),
kernel_regularizer = my_regularizer))
Activaciones
En el aprendizaje automático, la función de activación es una función especial que se utiliza para encontrar si una neurona específica está activada o no. Básicamente, la función de activación realiza una transformación no lineal de los datos de entrada y, por lo tanto, permite que las neuronas aprendan mejor. La salida de una neurona depende de la función de activación.
Como recordará el concepto de percepción única, la salida de un perceptrón (neurona) es simplemente el resultado de la función de activación, que acepta la suma de todas las entradas multiplicadas por su peso correspondiente más el sesgo general, si hay alguno disponible.
result = Activation(SUMOF(input * weight) + bias)
Entonces, la función de activación juega un papel importante en el aprendizaje exitoso del modelo. Keras proporciona muchas funciones de activación en el módulo de activaciones. Aprendamos todas las activaciones disponibles en el módulo.
lineal
Aplica la función lineal. No hace nada.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'linear', input_shape = (784,)))
Dónde, activationse refiere a la función de activación de la capa. Se puede especificar simplemente por el nombre de la función y la capa utilizará los activadores correspondientes.
elu
Aplica unidad lineal exponencial.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'elu', input_shape = (784,)))
selu
Aplica la unidad lineal exponencial escalada.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'selu', input_shape = (784,)))
relu
Aplica unidad lineal rectificada.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,)))
softmax
Aplica la función Softmax.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softmax', input_shape = (784,)))
softplus
Aplica la función Softplus.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softplus', input_shape = (784,)))
softsign
Aplica la función Softsign.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'softsign', input_shape = (784,)))
tanh
Aplica la función de tangente hiperbólica.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'tanh', input_shape = (784,)))
sigmoideo
Aplica la función sigmoidea.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'sigmoid', input_shape = (784,)))
hard_sigmoid
Aplica la función sigmoidea dura.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'hard_sigmoid', input_shape = (784,)))
exponencial
Aplica función exponencial.
from keras.models import Sequential
from keras.layers import Activation, Dense
model = Sequential()
model.add(Dense(512, activation = 'exponential', input_shape = (784,)))
No Señor | Capas y descripción |
---|---|
1 | Capa densa Dense layer es la capa regular de la red neuronal profundamente conectada. |
2 | Capas de abandono Dropout es uno de los conceptos importantes en el aprendizaje automático. |
3 | Aplanar capas Flatten se utiliza para aplanar la entrada. |
4 | Cambiar la forma de las capas Reshape se utiliza para cambiar la forma de la entrada. |
5 | Permutar capas Permute también se usa para cambiar la forma de la entrada usando patrón. |
6 | Repetir Capas vectoriales RepeatVector se utiliza para repetir la entrada para el número establecido, n veces. |
7 | Capas Lambda Lambda se utiliza para transformar los datos de entrada mediante una expresión o función. |
8 | Capas de convolución Keras contiene muchas capas para crear ANN basado en convolución, popularmente llamado como red neuronal de convolución (CNN) . |
9 | Capa de agrupación Se utiliza para realizar operaciones de agrupación máxima en datos temporales. |
10 | Capa conectada localmente Las capas conectadas localmente son similares a la capa Conv1D, pero la diferencia es que los pesos de las capas Conv1D se comparten, pero aquí los pesos no se comparten. |
11 | Fusionar capa Se utiliza para fusionar una lista de entradas. |
12 | Capa de incrustación Realiza operaciones de incrustación en la capa de entrada. |
Keras - Capa personalizada
Keras permite crear nuestra propia capa personalizada. Una vez que se crea una nueva capa, se puede utilizar en cualquier modelo sin ninguna restricción. Aprendamos a crear una nueva capa en este capítulo.
Keras proporciona una base layerclase, capa que se puede subclasificar para crear nuestra propia capa personalizada. Creemos una capa simple que encuentre el peso basado en la distribución normal y luego hagamos el cálculo básico de encontrar la suma del producto de entrada y su peso durante el entrenamiento.
Paso 1: Importa el módulo necesario
Primero, importemos los módulos necesarios:
from keras import backend as K
from keras.layers import Layer
Aquí,
backend se utiliza para acceder al dot función.
Layer es la clase base y la subclasificaremos para crear nuestra capa
Paso 2: definir una clase de capa
Creemos una nueva clase, MyCustomLayer subclasificando Layer class -
class MyCustomLayer(Layer):
...
Paso 3: inicializar la clase de capa
Inicialicemos nuestra nueva clase como se especifica a continuación:
def __init__(self, output_dim, **kwargs):
self.output_dim = output_dim
super(MyCustomLayer, self).__init__(**kwargs)
Aquí,
Line 2 establece la dimensión de salida.
Line 3 llama a la base o supercapa init función.
Paso 4: implementar el método de construcción
buildes el método principal y su único propósito es construir la capa correctamente. Puede hacer cualquier cosa relacionada con el funcionamiento interno de la capa. Una vez que se realiza la funcionalidad personalizada, podemos llamar a la clase basebuildfunción. Nuestra costumbrebuild la función es la siguiente:
def build(self, input_shape):
self.kernel = self.add_weight(name = 'kernel',
shape = (input_shape[1], self.output_dim),
initializer = 'normal', trainable = True)
super(MyCustomLayer, self).build(input_shape)
Aquí,
Line 1 define el build método con un argumento, input_shape. La forma de los datos de entrada se refiere a input_shape.
Line 2crea el peso correspondiente a la forma de entrada y lo establece en el kernel. Es nuestra funcionalidad personalizada de la capa. Crea el peso usando un inicializador 'normal'.
Line 6 llama a la clase base, build método.
Paso 5: implementar el método de llamada
call El método hace el trabajo exacto de la capa durante el proceso de entrenamiento.
Nuestra costumbre call el método es el siguiente
def call(self, input_data):
return K.dot(input_data, self.kernel)
Aquí,
Line 1 define el call método con un argumento, input_data. input_data son los datos de entrada para nuestra capa.
Line 2 devolver el producto escalar de los datos de entrada, input_data y el núcleo de nuestra capa, self.kernel
Paso 6: implementar el método compute_output_shape
def compute_output_shape(self, input_shape): return (input_shape[0], self.output_dim)
Aquí,
Line 1 define compute_output_shape método con un argumento input_shape
Line 2 calcula la forma de salida usando la forma de los datos de entrada y la dimensión de salida establecida mientras inicializa la capa.
Implementando el build, call y compute_output_shapecompleta la creación de una capa personalizada. El código final y completo es el siguiente
from keras import backend as K from keras.layers import Layer
class MyCustomLayer(Layer):
def __init__(self, output_dim, **kwargs):
self.output_dim = output_dim
super(MyCustomLayer, self).__init__(**kwargs)
def build(self, input_shape): self.kernel =
self.add_weight(name = 'kernel',
shape = (input_shape[1], self.output_dim),
initializer = 'normal', trainable = True)
super(MyCustomLayer, self).build(input_shape) #
Be sure to call this at the end
def call(self, input_data): return K.dot(input_data, self.kernel)
def compute_output_shape(self, input_shape): return (input_shape[0], self.output_dim)
Usando nuestra capa personalizada
Creemos un modelo simple usando nuestra capa personalizada como se especifica a continuación:
from keras.models import Sequential
from keras.layers import Dense
model = Sequential()
model.add(MyCustomLayer(32, input_shape = (16,)))
model.add(Dense(8, activation = 'softmax')) model.summary()
Aquí,
Nuestra MyCustomLayer se agrega al modelo usando 32 unidades y (16,) como forma de entrada
Al ejecutar la aplicación, se imprimirá el resumen del modelo como se muestra a continuación:
Model: "sequential_1"
_________________________________________________________________
Layer (type) Output Shape Param
#================================================================
my_custom_layer_1 (MyCustomL (None, 32) 512
_________________________________________________________________
dense_1 (Dense) (None, 8) 264
=================================================================
Total params: 776
Trainable params: 776
Non-trainable params: 0
_________________________________________________________________
Keras - Modelos
Como se aprendió anteriormente, el modelo de Keras representa el modelo de red neuronal real. Keras proporciona dos modos para crear el modelo, API secuencial simple y fácil de usar , así como API funcional más flexible y avanzada . Aprendamos ahora a crear modelos usando API secuenciales y funcionales en este capítulo.
Secuencial
La idea central de Sequential APIes simplemente organizar las capas de Keras en un orden secuencial y, por lo tanto, se llama API secuencial . La mayor parte de la ANN también tiene capas en orden secuencial y los datos fluyen de una capa a otra en el orden dado hasta que los datos finalmente llegan a la capa de salida.
Se puede crear un modelo ANN simplemente llamando Sequential() API como se especifica a continuación -
from keras.models import Sequential
model = Sequential()
Agregar capas
Para agregar una capa, simplemente cree una capa usando la API de capa de Keras y luego pase la capa a través de la función add () como se especifica a continuación:
from keras.models import Sequential
model = Sequential()
input_layer = Dense(32, input_shape=(8,)) model.add(input_layer)
hidden_layer = Dense(64, activation='relu'); model.add(hidden_layer)
output_layer = Dense(8)
model.add(output_layer)
Aquí, hemos creado una capa de entrada, una capa oculta y una capa de salida.
Accede al modelo
Keras proporciona algunos métodos para obtener la información del modelo, como capas, datos de entrada y datos de salida. Son los siguientes:
model.layers - Devuelve todas las capas del modelo como lista.
>>> layers = model.layers
>>> layers
[
<keras.layers.core.Dense object at 0x000002C8C888B8D0>,
<keras.layers.core.Dense object at 0x000002C8C888B7B8>
<keras.layers.core.Dense object at 0x 000002C8C888B898>
]
model.inputs - Devuelve todos los tensores de entrada del modelo como lista.
>>> inputs = model.inputs
>>> inputs
[<tf.Tensor 'dense_13_input:0' shape=(?, 8) dtype=float32>]
model.outputs - Devuelve todos los tensores de salida del modelo como lista.
>>> outputs = model.outputs
>>> outputs
<tf.Tensor 'dense_15/BiasAdd:0' shape=(?, 8) dtype=float32>]
model.get_weights - Devuelve todos los pesos como matrices NumPy.
model.set_weights(weight_numpy_array) - Establecer los pesos del modelo.
Serializar el modelo
Keras proporciona métodos para serializar el modelo en un objeto y json y volver a cargarlo más tarde. Son los siguientes:
get_config() - I Devuelve el modelo como objeto.
config = model.get_config()
from_config() - Acepta el objeto de configuración del modelo como argumento y crea el modelo en consecuencia.
new_model = Sequential.from_config(config)
to_json() - Devuelve el modelo como un objeto json.
>>> json_string = model.to_json()
>>> json_string '{"class_name": "Sequential", "config":
{"name": "sequential_10", "layers":
[{"class_name": "Dense", "config":
{"name": "dense_13", "trainable": true, "batch_input_shape":
[null, 8], "dtype": "float32", "units": 32, "activation": "linear",
"use_bias": true, "kernel_initializer":
{"class_name": "Vari anceScaling", "config":
{"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}},
"bias_initializer": {"class_name": "Zeros", "conf
ig": {}}, "kernel_regularizer": null, "bias_regularizer": null,
"activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}},
{" class_name": "Dense", "config": {"name": "dense_14", "trainable": true,
"dtype": "float32", "units": 64, "activation": "relu", "use_bias": true,
"kern el_initializer": {"class_name": "VarianceScaling", "config":
{"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}},
"bias_initia lizer": {"class_name": "Zeros",
"config": {}}, "kernel_regularizer": null, "bias_regularizer": null,
"activity_regularizer": null, "kernel_constraint" : null, "bias_constraint": null}},
{"class_name": "Dense", "config": {"name": "dense_15", "trainable": true,
"dtype": "float32", "units": 8, "activation": "linear", "use_bias": true,
"kernel_initializer": {"class_name": "VarianceScaling", "config":
{"scale": 1.0, "mode": "fan_avg", "distribution": " uniform", "seed": null}},
"bias_initializer": {"class_name": "Zeros", "config": {}},
"kernel_regularizer": null, "bias_regularizer": null, "activity_r egularizer":
null, "kernel_constraint": null, "bias_constraint":
null}}]}, "keras_version": "2.2.5", "backend": "tensorflow"}'
>>>
model_from_json() - Acepta la representación json del modelo y crea un nuevo modelo.
from keras.models import model_from_json
new_model = model_from_json(json_string)
to_yaml() - Devuelve el modelo como una cadena yaml.
>>> yaml_string = model.to_yaml()
>>> yaml_string 'backend: tensorflow\nclass_name:
Sequential\nconfig:\n layers:\n - class_name: Dense\n config:\n
activation: linear\n activity_regular izer: null\n batch_input_shape:
!!python/tuple\n - null\n - 8\n bias_constraint: null\n bias_initializer:\n
class_name : Zeros\n config: {}\n bias_regularizer: null\n dtype:
float32\n kernel_constraint: null\n
kernel_initializer:\n cla ss_name: VarianceScaling\n config:\n
distribution: uniform\n mode: fan_avg\n
scale: 1.0\n seed: null\n kernel_regularizer: null\n name: dense_13\n
trainable: true\n units: 32\n
use_bias: true\n - class_name: Dense\n config:\n activation: relu\n activity_regularizer: null\n
bias_constraint: null\n bias_initializer:\n class_name: Zeros\n
config : {}\n bias_regularizer: null\n dtype: float32\n
kernel_constraint: null\n kernel_initializer:\n class_name: VarianceScalin g\n
config:\n distribution: uniform\n mode: fan_avg\n scale: 1.0\n
seed: null\n kernel_regularizer: nu ll\n name: dense_14\n trainable: true\n
units: 64\n use_bias: true\n - class_name: Dense\n config:\n
activation: linear\n activity_regularizer: null\n
bias_constraint: null\n bias_initializer:\n
class_name: Zeros\n config: {}\n bias_regu larizer: null\n
dtype: float32\n kernel_constraint: null\n
kernel_initializer:\n class_name: VarianceScaling\n config:\n
distribution: uniform\n mode: fan_avg\n
scale: 1.0\n seed: null\n kernel_regularizer: null\n name: dense _15\n
trainable: true\n units: 8\n
use_bias: true\n name: sequential_10\nkeras_version: 2.2.5\n'
>>>
model_from_yaml() - Acepta la representación yaml del modelo y crea un nuevo modelo.
from keras.models import model_from_yaml
new_model = model_from_yaml(yaml_string)
Resume el modelo
Comprender el modelo es una fase muy importante para utilizarlo correctamente con fines de entrenamiento y predicción. Keras proporciona un método simple, resumen para obtener la información completa sobre el modelo y sus capas.
Un resumen del modelo creado en la sección anterior es el siguiente:
>>> model.summary() Model: "sequential_10"
_________________________________________________________________
Layer (type) Output Shape Param
#================================================================
dense_13 (Dense) (None, 32) 288
_________________________________________________________________
dense_14 (Dense) (None, 64) 2112
_________________________________________________________________
dense_15 (Dense) (None, 8) 520
=================================================================
Total params: 2,920
Trainable params: 2,920
Non-trainable params: 0
_________________________________________________________________
>>>
Entrenar y predecir el modelo
El modelo proporciona una función para el proceso de entrenamiento, evaluación y predicción. Son los siguientes:
compile - Configurar el proceso de aprendizaje del modelo
fit - Entrena el modelo usando los datos de entrenamiento
evaluate - Evaluar el modelo utilizando los datos de prueba.
predict - Predecir los resultados para nuevas entradas.
API funcional
La API secuencial se utiliza para crear modelos capa por capa. La API funcional es un enfoque alternativo para crear modelos más complejos. Modelo funcional, puede definir múltiples entradas o salidas que comparten capas. Primero, creamos una instancia para el modelo y nos conectamos a las capas para acceder a la entrada y salida del modelo. Esta sección explica brevemente el modelo funcional.
Crea un modelo
Importe una capa de entrada utilizando el módulo siguiente:
>>> from keras.layers import Input
Ahora, cree una capa de entrada que especifique la forma de la dimensión de entrada para el modelo usando el siguiente código:
>>> data = Input(shape=(2,3))
Defina la capa para la entrada usando el módulo siguiente:
>>> from keras.layers import Dense
Agregue una capa densa para la entrada usando la siguiente línea de código:
>>> layer = Dense(2)(data)
>>> print(layer)
Tensor("dense_1/add:0", shape =(?, 2, 2), dtype = float32)
Defina el modelo utilizando el módulo siguiente:
from keras.models import Model
Cree un modelo de manera funcional especificando tanto la capa de entrada como la de salida -
model = Model(inputs = data, outputs = layer)
El código completo para crear un modelo simple se muestra a continuación:
from keras.layers import Input
from keras.models import Model
from keras.layers import Dense
data = Input(shape=(2,3))
layer = Dense(2)(data) model =
Model(inputs=data,outputs=layer) model.summary()
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input_2 (InputLayer) (None, 2, 3) 0
_________________________________________________________________
dense_2 (Dense) (None, 2, 2) 8
=================================================================
Total params: 8
Trainable params: 8
Non-trainable params: 0
_________________________________________________________________
Keras - Compilación de modelos
Anteriormente, estudiamos los conceptos básicos de cómo crear un modelo utilizando API secuencial y funcional. Este capítulo explica cómo compilar el modelo. La compilación es el paso final para crear un modelo. Una vez realizada la compilación, podemos pasar a la fase de entrenamiento.
Aprendamos algunos conceptos necesarios para comprender mejor el proceso de compilación.
Pérdida
En el aprendizaje automático, LossLa función se utiliza para encontrar errores o desviaciones en el proceso de aprendizaje. Keras requiere la función de pérdida durante el proceso de compilación del modelo.
Keras proporciona bastantes funciones de pérdida en el losses módulo y son los siguientes:
- mean_squared_error
- mean_absolute_error
- mean_absolute_percentage_error
- mean_squared_logarithmic_error
- squared_hinge
- hinge
- categorical_hinge
- logcosh
- huber_loss
- categorical_crossentropy
- sparse_categorical_crossentropy
- binary_crossentropy
- kullback_leibler_divergence
- poisson
- cosine_proximity
- is_categorical_crossentropy
Toda la función de pérdida anterior acepta dos argumentos:
y_true - etiquetas verdaderas como tensores
y_pred - predicción con la misma forma que y_true
Importe el módulo de pérdidas antes de usar la función de pérdida como se especifica a continuación:
from keras import losses
Optimizador
En el aprendizaje automático, Optimizationes un proceso importante que optimiza los pesos de entrada comparando la predicción y la función de pérdida. Keras proporciona bastantes optimizadores como módulo, optimizadores y son los siguientes:
SGD - Optimizador de descenso de gradiente estocástico.
keras.optimizers.SGD(learning_rate = 0.01, momentum = 0.0, nesterov = False)
RMSprop - Optimizador RMSProp.
keras.optimizers.RMSprop(learning_rate = 0.001, rho = 0.9)
Adagrad - Optimizador Adagrad.
keras.optimizers.Adagrad(learning_rate = 0.01)
Adadelta - Optimizador Adadelta.
keras.optimizers.Adadelta(learning_rate = 1.0, rho = 0.95)
Adam - Optimizador de Adam.
keras.optimizers.Adam(
learning_rate = 0.001, beta_1 = 0.9, beta_2 = 0.999, amsgrad = False
)
Adamax - Optimizador Adamax de Adam.
keras.optimizers.Adamax(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)
Nadam - Optimizador de Nesterov Adam.
keras.optimizers.Nadam(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)
Importe el módulo de optimizadores antes de usar los optimizadores como se especifica a continuación:
from keras import optimizers
Métrica
En el aprendizaje automático, Metricsse utiliza para evaluar el rendimiento de su modelo. Es similar a la función de pérdida, pero no se usa en el proceso de entrenamiento. Keras proporciona bastantes métricas como módulo,metrics y son los siguientes
- accuracy
- binary_accuracy
- categorical_accuracy
- sparse_categorical_accuracy
- top_k_categorical_accuracy
- sparse_top_k_categorical_accuracy
- cosine_proximity
- clone_metric
Similar a la función de pérdida, las métricas también aceptan debajo de dos argumentos:
y_true - etiquetas verdaderas como tensores
y_pred - predicción con la misma forma que y_true
Importe el módulo de métricas antes de usar las métricas como se especifica a continuación:
from keras import metrics
Compila el modelo
El modelo de Keras proporciona un método, compile()para compilar el modelo. El argumento y el valor predeterminado de lacompile() el método es el siguiente
compile(
optimizer,
loss = None,
metrics = None,
loss_weights = None,
sample_weight_mode = None,
weighted_metrics = None,
target_tensors = None
)
Los argumentos importantes son los siguientes:
- función de pérdida
- Optimizer
- metrics
Un código de muestra para compilar el modo es el siguiente:
from keras import losses
from keras import optimizers
from keras import metrics
model.compile(loss = 'mean_squared_error',
optimizer = 'sgd', metrics = [metrics.categorical_accuracy])
dónde,
la función de pérdida se establece como mean_squared_error
el optimizador está configurado como sgd
las métricas se establecen como metrics.categorical_accuracy
Entrenamiento de modelos
Los modelos son entrenados por matrices NumPy usando fit(). El objetivo principal de esta función de ajuste se utiliza para evaluar su modelo en el entrenamiento. Esto también se puede utilizar para graficar el rendimiento del modelo. Tiene la siguiente sintaxis:
model.fit(X, y, epochs = , batch_size = )
Aquí,
X, y - Es una tupla para evaluar sus datos.
epochs - ninguna de las veces que es necesario evaluar el modelo durante el entrenamiento.
batch_size - instancias de formación.
Tomemos un ejemplo simple de numerosos datos aleatorios para usar este concepto.
Crear datos
Creemos datos aleatorios usando numpy para xey con la ayuda del comando mencionado a continuación:
import numpy as np
x_train = np.random.random((100,4,8))
y_train = np.random.random((100,10))
Ahora, cree datos de validación aleatorios,
x_val = np.random.random((100,4,8))
y_val = np.random.random((100,10))
Crear modelo
Creemos un modelo secuencial simple:
from keras.models import Sequential model = Sequential()
Agregar capas
Crear capas para agregar modelo -
from keras.layers import LSTM, Dense
# add a sequence of vectors of dimension 16
model.add(LSTM(16, return_sequences = True))
model.add(Dense(10, activation = 'softmax'))
compilar modelo
Ahora el modelo está definido. Puede compilar usando el siguiente comando:
model.compile(
loss = 'categorical_crossentropy', optimizer = 'sgd', metrics = ['accuracy']
)
Aplicar ajuste ()
Ahora aplicamos la función fit () para entrenar nuestros datos -
model.fit(x_train, y_train, batch_size = 32, epochs = 5, validation_data = (x_val, y_val))
Crear una ANN de perceptrón multicapa
Hemos aprendido a crear, compilar y entrenar los modelos de Keras.
Apliquemos nuestro aprendizaje y creemos una RNA basada en MPL simple.
Módulo de conjunto de datos
Antes de crear un modelo, debemos elegir un problema, recopilar los datos necesarios y convertir los datos en una matriz NumPy. Una vez que se recopilan los datos, podemos preparar el modelo y entrenarlo utilizando los datos recopilados. La recopilación de datos es una de las fases más difíciles del aprendizaje automático. Keras proporciona un módulo especial, conjuntos de datos para descargar los datos de aprendizaje automático en línea con fines de capacitación. Obtiene los datos del servidor en línea, procesa los datos y devuelve los datos como conjunto de entrenamiento y prueba. Comprobemos los datos proporcionados por el módulo del conjunto de datos de Keras. Los datos disponibles en el módulo son los siguientes,
- Clasificación de imágenes pequeñas CIFAR10
- Clasificación de imágenes pequeñas CIFAR100
- Clasificación de sentimiento de reseñas de películas de IMDB
- Clasificación de temas de Reuters Newswire
- Base de datos MNIST de dígitos escritos a mano
- Base de datos Fashion-MNIST de artículos de moda
- Conjunto de datos de regresión del precio de la vivienda en Boston
Usemos el MNIST database of handwritten digits(o minst) como nuestra entrada. minst es una colección de 60.000 imágenes en escala de grises de 28x28. Contiene 10 dígitos. También contiene 10,000 imágenes de prueba.
El siguiente código se puede usar para cargar el conjunto de datos:
from keras.datasets import mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
dónde
Line 1 importaciones minst desde el módulo de conjunto de datos de keras.
Line 3 llama al load_data función, que obtendrá los datos del servidor en línea y devolverá los datos como 2 tuplas, Primera tupla, (x_train, y_train) representar los datos de entrenamiento con forma, (number_sample, 28, 28) y su etiqueta de dígitos con forma, (number_samples, ). Segunda tupla,(x_test, y_test) representan datos de prueba con la misma forma.
También se pueden obtener otros conjuntos de datos utilizando una API similar y cada API también devuelve datos similares, excepto la forma de los datos. La forma de los datos depende del tipo de datos.
Crea un modelo
Elijamos un perceptrón multicapa simple (MLP) como se representa a continuación e intentemos crear el modelo usando Keras.
Las características principales del modelo son las siguientes:
La capa de entrada consta de 784 valores (28 x 28 = 784).
Primera capa oculta, Dense consta de 512 neuronas y función de activación 'relu'.
Segunda capa oculta, Dropout tiene 0,2 como valor.
La tercera capa oculta, nuevamente Densa, consta de 512 neuronas y la función de activación 'relu'.
Cuarta capa oculta, Dropout tiene 0,2 como valor.
La quinta y última capa consta de 10 neuronas y la función de activación 'softmax'.
Utilizar categorical_crossentropy como función de pérdida.
Utilizar RMSprop() como Optimizador.
Utilizar accuracy como métricas.
Utilice 128 como tamaño de lote.
Usa 20 como épocas.
Step 1 − Import the modules
Importamos los módulos necesarios.
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import RMSprop
import numpy as np
Step 2 − Load data
Importemos el conjunto de datos mnist.
(x_train, y_train), (x_test, y_test) = mnist.load_data()
Step 3 − Process the data
Cambiemos el conjunto de datos de acuerdo con nuestro modelo, para que se pueda incorporar a nuestro modelo.
x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)
Dónde
reshape se usa para remodelar la entrada de (28, 28) tupla a (784,)
to_categorical se utiliza para convertir vector a matriz binaria
Step 4 − Create the model
Creemos el modelo real.
model = Sequential()
model.add(Dense(512, activation = 'relu', input_shape = (784,)))
model.add(Dropout(0.2))
model.add(Dense(512, activation = 'relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation = 'softmax'))
Step 5 − Compile the model
Compilemos el modelo utilizando la función de pérdida seleccionada, el optimizador y las métricas.
model.compile(loss = 'categorical_crossentropy',
optimizer = RMSprop(),
metrics = ['accuracy'])
Step 6 − Train the model
Entrenemos el modelo usando fit() método.
history = model.fit(
x_train, y_train,
batch_size = 128,
epochs = 20,
verbose = 1,
validation_data = (x_test, y_test)
)
Pensamientos finales
Hemos creado el modelo, hemos cargado los datos y también hemos entrenado los datos al modelo. Todavía necesitamos evaluar el modelo y predecir la salida para la entrada desconocida, lo que aprenderemos en el próximo capítulo.
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import RMSprop
import numpy as np
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)
model = Sequential()
model.add(Dense(512, activation='relu', input_shape = (784,)))
model.add(Dropout(0.2))
model.add(Dense(512, activation = 'relu')) model.add(Dropout(0.2))
model.add(Dense(10, activation = 'softmax'))
model.compile(loss = 'categorical_crossentropy',
optimizer = RMSprop(),
metrics = ['accuracy'])
history = model.fit(x_train, y_train,
batch_size = 128, epochs = 20, verbose = 1, validation_data = (x_test, y_test))
La ejecución de la aplicación dará como resultado el siguiente contenido:
Train on 60000 samples, validate on 10000 samples Epoch 1/20
60000/60000 [==============================] - 7s 118us/step - loss: 0.2453
- acc: 0.9236 - val_loss: 0.1004 - val_acc: 0.9675 Epoch 2/20
60000/60000 [==============================] - 7s 110us/step - loss: 0.1023
- acc: 0.9693 - val_loss: 0.0797 - val_acc: 0.9761 Epoch 3/20
60000/60000 [==============================] - 7s 110us/step - loss: 0.0744
- acc: 0.9770 - val_loss: 0.0727 - val_acc: 0.9791 Epoch 4/20
60000/60000 [==============================] - 7s 110us/step - loss: 0.0599
- acc: 0.9823 - val_loss: 0.0704 - val_acc: 0.9801 Epoch 5/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0504
- acc: 0.9853 - val_loss: 0.0714 - val_acc: 0.9817 Epoch 6/20
60000/60000 [==============================] - 7s 111us/step - loss: 0.0438
- acc: 0.9868 - val_loss: 0.0845 - val_acc: 0.9809 Epoch 7/20
60000/60000 [==============================] - 7s 114us/step - loss: 0.0391
- acc: 0.9887 - val_loss: 0.0823 - val_acc: 0.9802 Epoch 8/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0364
- acc: 0.9892 - val_loss: 0.0818 - val_acc: 0.9830 Epoch 9/20
60000/60000 [==============================] - 7s 113us/step - loss: 0.0308
- acc: 0.9905 - val_loss: 0.0833 - val_acc: 0.9829 Epoch 10/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0289
- acc: 0.9917 - val_loss: 0.0947 - val_acc: 0.9815 Epoch 11/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0279
- acc: 0.9921 - val_loss: 0.0818 - val_acc: 0.9831 Epoch 12/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0260
- acc: 0.9927 - val_loss: 0.0945 - val_acc: 0.9819 Epoch 13/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0257
- acc: 0.9931 - val_loss: 0.0952 - val_acc: 0.9836 Epoch 14/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0229
- acc: 0.9937 - val_loss: 0.0924 - val_acc: 0.9832 Epoch 15/20
60000/60000 [==============================] - 7s 115us/step - loss: 0.0235
- acc: 0.9937 - val_loss: 0.1004 - val_acc: 0.9823 Epoch 16/20
60000/60000 [==============================] - 7s 113us/step - loss: 0.0214
- acc: 0.9941 - val_loss: 0.0991 - val_acc: 0.9847 Epoch 17/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0219
- acc: 0.9943 - val_loss: 0.1044 - val_acc: 0.9837 Epoch 18/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0190
- acc: 0.9952 - val_loss: 0.1129 - val_acc: 0.9836 Epoch 19/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0197
- acc: 0.9953 - val_loss: 0.0981 - val_acc: 0.9841 Epoch 20/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0198
- acc: 0.9950 - val_loss: 0.1215 - val_acc: 0.9828
Keras - Evaluación de modelos y predicción de modelos
Este capítulo trata sobre la evaluación y la predicción del modelo en Keras.
Comencemos por comprender la evaluación del modelo.
Evaluación del modelo
La evaluación es un proceso durante el desarrollo del modelo para verificar si el modelo se ajusta mejor al problema dado y los datos correspondientes. El modelo de Keras proporciona una función, evaluar cuál hace la evaluación del modelo. Tiene tres argumentos principales,
- Datos de prueba
- Etiqueta de datos de prueba
- detallado - verdadero o falso
Evaluemos el modelo que creamos en el capítulo anterior usando datos de prueba.
score = model.evaluate(x_test, y_test, verbose = 0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
La ejecución del código anterior generará la siguiente información.
0
La precisión de la prueba es del 98,28%. Hemos creado el mejor modelo para identificar los dígitos de la escritura a mano. En el lado positivo, todavía podemos mejorar nuestro modelo.
Predicción del modelo
Predictiones el paso final y nuestro resultado esperado de la generación del modelo. Keras proporciona un método de predicción para obtener la predicción del modelo entrenado. La firma del método de predicción es la siguiente,
predict(
x,
batch_size = None,
verbose = 0,
steps = None,
callbacks = None,
max_queue_size = 10,
workers = 1,
use_multiprocessing = False
)
Aquí, todos los argumentos son opcionales excepto el primer argumento, que se refiere a los datos de entrada desconocidos. La forma debe mantenerse para obtener la predicción adecuada.
Hagamos predicciones para nuestro modelo MPL creado en el capítulo anterior usando el siguiente código:
pred = model.predict(x_test)
pred = np.argmax(pred, axis = 1)[:5]
label = np.argmax(y_test,axis = 1)[:5]
print(pred)
print(label)
Aquí,
Line 1 Llame a la función de predicción utilizando datos de prueba.
Line 2 obtiene las cinco primeras predicciones
Line 3 obtiene las primeras cinco etiquetas de los datos de prueba.
Line 5 - 6 imprime la predicción y la etiqueta real.
El resultado de la aplicación anterior es el siguiente:
[7 2 1 0 4]
[7 2 1 0 4]
La salida de ambas matrices es idéntica e indica que nuestro modelo predice correctamente las primeras cinco imágenes.
Keras - Red neuronal de convolución
Modifiquemos el modelo de MPL a Convolution Neural Network (CNN) para nuestro problema de identificación de dígitos anterior.
CNN se puede representar de la siguiente manera:
Las características principales del modelo son las siguientes:
La capa de entrada consta de (1, 8, 28) valores.
Primera capa, Conv2D consta de 32 filtros y función de activación 'relu' con tamaño de kernel, (3,3).
Segunda capa, Conv2D consta de 64 filtros y función de activación 'relu' con tamaño de kernel, (3,3).
Tercera capa, MaxPooling Tiene un tamaño de piscina de (2, 2).
Quinta capa, Flatten se utiliza para aplanar toda su entrada en una sola dimensión.
Sexta capa, Dense consta de 128 neuronas y función de activación 'relu'.
Séptima capa, Dropout tiene 0,5 como valor.
La octava y última capa consta de 10 neuronas y la función de activación 'softmax'.
Utilizar categorical_crossentropy como función de pérdida.
Utilizar Adadelta() como Optimizador.
Utilizar accuracy como métricas.
Utilice 128 como tamaño de lote.
Usa 20 como épocas.
Step 1 − Import the modules
Importamos los módulos necesarios.
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K
import numpy as np
Step 2 − Load data
Importemos el conjunto de datos mnist.
(x_train, y_train), (x_test, y_test) = mnist.load_data()
Step 3 − Process the data
Cambiemos el conjunto de datos de acuerdo con nuestro modelo, para que se pueda incorporar a nuestro modelo.
img_rows, img_cols = 28, 28
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)
El procesamiento de datos es similar al modelo MPL excepto la forma de los datos de entrada y la configuración del formato de imagen.
Step 4 − Create the model
Creemos el modelo actual.
model = Sequential()
model.add(Conv2D(32, kernel_size = (3, 3),
activation = 'relu', input_shape = input_shape))
model.add(Conv2D(64, (3, 3), activation = 'relu'))
model.add(MaxPooling2D(pool_size = (2, 2)))
model.add(Dropout(0.25)) model.add(Flatten())
model.add(Dense(128, activation = 'relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation = 'softmax'))
Step 5 − Compile the model
Compilemos el modelo utilizando la función de pérdida seleccionada, el optimizador y las métricas.
model.compile(loss = keras.losses.categorical_crossentropy,
optimizer = keras.optimizers.Adadelta(), metrics = ['accuracy'])
Step 6 − Train the model
Entrenemos el modelo usando fit() método.
model.fit(
x_train, y_train,
batch_size = 128,
epochs = 12,
verbose = 1,
validation_data = (x_test, y_test)
)
La ejecución de la aplicación generará la siguiente información:
Train on 60000 samples, validate on 10000 samples Epoch 1/12
60000/60000 [==============================] - 84s 1ms/step - loss: 0.2687
- acc: 0.9173 - val_loss: 0.0549 - val_acc: 0.9827 Epoch 2/12
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0899
- acc: 0.9737 - val_loss: 0.0452 - val_acc: 0.9845 Epoch 3/12
60000/60000 [==============================] - 83s 1ms/step - loss: 0.0666
- acc: 0.9804 - val_loss: 0.0362 - val_acc: 0.9879 Epoch 4/12
60000/60000 [==============================] - 81s 1ms/step - loss: 0.0564
- acc: 0.9830 - val_loss: 0.0336 - val_acc: 0.9890 Epoch 5/12
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0472
- acc: 0.9861 - val_loss: 0.0312 - val_acc: 0.9901 Epoch 6/12
60000/60000 [==============================] - 83s 1ms/step - loss: 0.0414
- acc: 0.9877 - val_loss: 0.0306 - val_acc: 0.9902 Epoch 7/12
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0375
-acc: 0.9883 - val_loss: 0.0281 - val_acc: 0.9906 Epoch 8/12
60000/60000 [==============================] - 91s 2ms/step - loss: 0.0339
- acc: 0.9893 - val_loss: 0.0280 - val_acc: 0.9912 Epoch 9/12
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0325
- acc: 0.9901 - val_loss: 0.0260 - val_acc: 0.9909 Epoch 10/12
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0284
- acc: 0.9910 - val_loss: 0.0250 - val_acc: 0.9919 Epoch 11/12
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0287
- acc: 0.9907 - val_loss: 0.0264 - val_acc: 0.9916 Epoch 12/12
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0265
- acc: 0.9920 - val_loss: 0.0249 - val_acc: 0.9922
Step 7 − Evaluate the model
Evaluemos el modelo usando datos de prueba.
score = model.evaluate(x_test, y_test, verbose = 0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
La ejecución del código anterior generará la siguiente información:
Test loss: 0.024936060590433316
Test accuracy: 0.9922
La precisión de la prueba es del 99,22%. Hemos creado el mejor modelo para identificar los dígitos de la escritura a mano.
Step 8 − Predict
Finalmente, predice el dígito a partir de imágenes como se muestra a continuación:
pred = model.predict(x_test)
pred = np.argmax(pred, axis = 1)[:5]
label = np.argmax(y_test,axis = 1)[:5]
print(pred)
print(label)
El resultado de la aplicación anterior es el siguiente:
[7 2 1 0 4]
[7 2 1 0 4]
La salida de ambas matrices es idéntica e indica que nuestro modelo predice correctamente las primeras cinco imágenes.
Keras - Predicción de regresión usando MPL
En este capítulo, escribiremos una RNA basada en MPL simple para realizar predicciones de regresión. Hasta ahora, solo hemos realizado la predicción basada en la clasificación. Ahora, intentaremos predecir el siguiente valor posible analizando los valores anteriores (continuos) y sus factores de influencia.
El MPL de regresión se puede representar de la siguiente manera:
Las características principales del modelo son las siguientes:
La capa de entrada consta de (13,) valores.
La primera capa, Dense , consta de 64 unidades y la función de activación 'relu' con un inicializador de kernel 'normal'.
Segunda capa, Dense consta de 64 unidades y función de activación 'relu'.
Capa de salida, Densa consta de 1 unidad.
Utilizar mse como función de pérdida.
Utilizar RMSprop como Optimizador.
Utilizar accuracy como métricas.
Utilice 128 como tamaño de lote.
Usa 500 como épocas.
Step 1 − Import the modules
Importamos los módulos necesarios.
import keras
from keras.datasets import boston_housing
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import RMSprop
from keras.callbacks import EarlyStopping
from sklearn import preprocessing
from sklearn.preprocessing import scale
Step 2 − Load data
Importemos el conjunto de datos de viviendas de Boston.
(x_train, y_train), (x_test, y_test) = boston_housing.load_data()
Aquí,
boston_housinges un conjunto de datos proporcionado por Keras. Representa una colección de información sobre viviendas en el área de Boston, cada una con 13 características.
Step 3 − Process the data
Cambiemos el conjunto de datos de acuerdo con nuestro modelo, para que podamos alimentar nuestro modelo. Los datos se pueden cambiar usando el siguiente código:
x_train_scaled = preprocessing.scale(x_train)
scaler = preprocessing.StandardScaler().fit(x_train)
x_test_scaled = scaler.transform(x_test)
Aquí, hemos normalizado los datos de entrenamiento usando sklearn.preprocessing.scale función. preprocessing.StandardScaler().fit La función devuelve un escalar con la media normalizada y la desviación estándar de los datos de entrenamiento, que podemos aplicar a los datos de prueba usando scalar.transformfunción. Esto normalizará los datos de la prueba también con la misma configuración que la de los datos de entrenamiento.
Step 4 − Create the model
Creemos el modelo real.
model = Sequential()
model.add(Dense(64, kernel_initializer = 'normal', activation = 'relu',
input_shape = (13,)))
model.add(Dense(64, activation = 'relu')) model.add(Dense(1))
Step 5 − Compile the model
Compilemos el modelo utilizando la función de pérdida seleccionada, el optimizador y las métricas.
model.compile(
loss = 'mse',
optimizer = RMSprop(),
metrics = ['mean_absolute_error']
)
Step 6 − Train the model
Entrenemos el modelo usando fit() método.
history = model.fit(
x_train_scaled, y_train,
batch_size=128,
epochs = 500,
verbose = 1,
validation_split = 0.2,
callbacks = [EarlyStopping(monitor = 'val_loss', patience = 20)]
)
Aquí, hemos utilizado la función de devolución de llamada, EarlyStopping. El propósito de esta devolución de llamada es monitorear el valor de pérdida durante cada época y compararlo con el valor de pérdida de la época anterior para encontrar la mejora en el entrenamiento. Si no hay mejora para elpatience veces, entonces todo el proceso se detendrá.
La ejecución de la aplicación dará como resultado la siguiente información:
Train on 323 samples, validate on 81 samples Epoch 1/500 2019-09-24 01:07:03.889046: I
tensorflow/core/platform/cpu_feature_guard.cc:142]
Your CPU supports instructions that this
TensorFlow binary was not co mpiled to use: AVX2 323/323
[==============================] - 0s 515us/step - loss: 562.3129
- mean_absolute_error: 21.8575 - val_loss: 621.6523 - val_mean_absolute_erro
r: 23.1730 Epoch 2/500
323/323 [==============================] - 0s 11us/step - loss: 545.1666
- mean_absolute_error: 21.4887 - val_loss: 605.1341 - val_mean_absolute_error
: 22.8293 Epoch 3/500
323/323 [==============================] - 0s 12us/step - loss: 528.9944
- mean_absolute_error: 21.1328 - val_loss: 588.6594 - val_mean_absolute_error
: 22.4799 Epoch 4/500
323/323 [==============================] - 0s 12us/step - loss: 512.2739
- mean_absolute_error: 20.7658 - val_loss: 570.3772 - val_mean_absolute_error
: 22.0853 Epoch 5/500
323/323 [==============================] - 0s 9us/step - loss: 493.9775
- mean_absolute_error: 20.3506 - val_loss: 550.9548 - val_mean_absolute_error: 21.6547
..........
..........
..........
Epoch 143/500
323/323 [==============================] - 0s 15us/step - loss: 8.1004
- mean_absolute_error: 2.0002 - val_loss: 14.6286 - val_mean_absolute_error:
2. 5904 Epoch 144/500
323/323 [==============================] - 0s 19us/step - loss: 8.0300
- mean_absolute_error: 1.9683 - val_loss: 14.5949 - val_mean_absolute_error:
2. 5843 Epoch 145/500
323/323 [==============================] - 0s 12us/step - loss: 7.8704
- mean_absolute_error: 1.9313 - val_loss: 14.3770 - val_mean_absolute_error: 2. 4996
Step 7 − Evaluate the model
Evaluemos el modelo usando datos de prueba.
score = model.evaluate(x_test_scaled, y_test, verbose = 0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
La ejecución del código anterior generará la siguiente información:
Test loss: 21.928471583946077 Test accuracy: 2.9599233234629914
Step 8 − Predict
Finalmente, prediga usando datos de prueba como se muestra a continuación:
prediction = model.predict(x_test_scaled)
print(prediction.flatten())
print(y_test)
El resultado de la aplicación anterior es el siguiente:
[ 7.5612316 17.583357 21.09344 31.859276 25.055613 18.673872 26.600405 22.403967 19.060272 22.264952
17.4191 17.00466 15.58924 41.624374 20.220217 18.985565 26.419338 19.837091 19.946192 36.43445
12.278508 16.330965 20.701359 14.345301 21.741161 25.050423 31.046402 27.738455 9.959419 20.93039
20.069063 14.518344 33.20235 24.735163 18.7274 9.148898 15.781284 18.556862 18.692865 26.045074
27.954073 28.106823 15.272034 40.879818 29.33896 23.714525 26.427515 16.483374 22.518442 22.425386
33.94826 18.831465 13.2501955 15.537227 34.639984 27.468002 13.474407 48.134598 34.39617
22.8503124.042334 17.747198 14.7837715 18.187277 23.655672 22.364983 13.858193 22.710032 14.371148
7.1272087 35.960033 28.247292 25.3014 14.477208 25.306196 17.891165 20.193708 23.585173 34.690193
12.200583 20.102983 38.45882 14.741723 14.408362 17.67158 18.418497 21.151712 21.157492 22.693687
29.809034 19.366991 20.072294 25.880817 40.814568 34.64087 19.43741 36.2591 50.73806 26.968863 43.91787
32.54908 20.248306 ] [ 7.2 18.8 19. 27. 22.2 24.5 31.2 22.9 20.5 23.2 18.6 14.5 17.8 50. 20.8 24.3 24.2
19.8 19.1 22.7 12. 10.2 20. 18.5 20.9 23. 27.5 30.1 9.5 22. 21.2 14.1 33.1 23.4 20.1 7.4 15.4 23.8 20.1
24.5 33. 28.4 14.1 46.7 32.5 29.6 28.4 19.8 20.2 25. 35.4 20.3 9.7 14.5 34.9 26.6 7.2 50. 32.4 21.6 29.8
13.1 27.5 21.2 23.1 21.9 13. 23.2 8.1 5.6 21.7 29.6 19.6 7. 26.4 18.9 20.9 28.1 35.4 10.2 24.3 43.1 17.6
15.4 16.2 27.1 21.4 21.5 22.4 25. 16.6 18.6 22. 42.8 35.1 21.5 36. 21.9 24.1 50. 26.7 25. ]
La salida de ambas matrices tiene una diferencia de alrededor del 10-30% e indica que nuestro modelo predice con un rango razonable.
Keras - Predicción de series temporales usando LSTM RNN
En este capítulo, vamos a escribir un RNN simple basado en la memoria a corto plazo (LSTM) para realizar análisis de secuencia. Una secuencia es un conjunto de valores donde cada valor corresponde a una instancia particular de tiempo. Consideremos un ejemplo simple de lectura de una oración. Leer y comprender una oración implica leer la palabra en el orden dado y tratar de comprender cada palabra y su significado en el contexto dado y finalmente comprender la oración en un sentimiento positivo o negativo.
Aquí, las palabras se consideran valores, y el primer valor corresponde a la primera palabra, el segundo valor corresponde a la segunda palabra, etc., y el orden se mantendrá estrictamente. Sequence Analysis se utiliza con frecuencia en el procesamiento del lenguaje natural para encontrar el análisis de sentimientos del texto dado.
Creemos un modelo LSTM para analizar las críticas de películas de IMDB y encontrar su sentimiento positivo / negativo.
El modelo para el análisis de secuencia se puede representar de la siguiente manera:
Las características principales del modelo son las siguientes:
Capa de entrada usando la capa de incrustación con 128 entidades.
La primera capa, Densa, consta de 128 unidades con deserción normal y deserción recurrente configuradas en 0.2.
Capa de salida, Dense consta de 1 unidad y función de activación 'sigmoide'.
Utilizar binary_crossentropy como función de pérdida.
Utilizar adam como Optimizador.
Utilizar accuracy como métricas.
Utilice 32 como tamaño de lote.
Usa 15 como épocas.
Utilice 80 como longitud máxima de la palabra.
Utilice 2000 como el número máximo de palabras en una oración dada.
Paso 1: importar los módulos
Importamos los módulos necesarios.
from keras.preprocessing import sequence
from keras.models import Sequential
from keras.layers import Dense, Embedding
from keras.layers import LSTM
from keras.datasets import imdb
Paso 2: cargar datos
Vamos a importar el conjunto de datos imdb.
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words = 2000)
Aquí,
imdbes un conjunto de datos proporcionado por Keras. Representa una colección de películas y sus críticas.
num_words representan el número máximo de palabras en la reseña.
Paso 3: procesa los datos
Cambiemos el conjunto de datos de acuerdo con nuestro modelo, para que se pueda introducir en nuestro modelo. Los datos se pueden cambiar usando el siguiente código:
x_train = sequence.pad_sequences(x_train, maxlen=80)
x_test = sequence.pad_sequences(x_test, maxlen=80)
Aquí,
sequence.pad_sequences convertir la lista de datos de entrada con forma, (data) en matriz de forma 2D NumPy (data, timesteps). Básicamente, agrega el concepto de pasos de tiempo a los datos proporcionados. Genera los pasos de tiempo de longitud,maxlen.
Paso 4: crea el modelo
Creemos el modelo real.
model = Sequential()
model.add(Embedding(2000, 128))
model.add(LSTM(128, dropout = 0.2, recurrent_dropout = 0.2))
model.add(Dense(1, activation = 'sigmoid'))
Aquí,
Hemos usado Embedding layercomo capa de entrada y luego agregó la capa LSTM. Finalmente, unDense layer se utiliza como capa de salida.
Paso 5: compila el modelo
Compilemos el modelo utilizando la función de pérdida seleccionada, el optimizador y las métricas.
model.compile(loss = 'binary_crossentropy',
optimizer = 'adam', metrics = ['accuracy'])
Paso 6: Entrena el modelo
LEntrenemos el modelo usando fit() método.
model.fit(
x_train, y_train,
batch_size = 32,
epochs = 15,
validation_data = (x_test, y_test)
)
La ejecución de la aplicación generará la siguiente información:
Epoch 1/15 2019-09-24 01:19:01.151247: I
tensorflow/core/platform/cpu_feature_guard.cc:142]
Your CPU supports instructions that this
TensorFlow binary was not co mpiled to use: AVX2
25000/25000 [==============================] - 101s 4ms/step - loss: 0.4707
- acc: 0.7716 - val_loss: 0.3769 - val_acc: 0.8349 Epoch 2/15
25000/25000 [==============================] - 95s 4ms/step - loss: 0.3058
- acc: 0.8756 - val_loss: 0.3763 - val_acc: 0.8350 Epoch 3/15
25000/25000 [==============================] - 91s 4ms/step - loss: 0.2100
- acc: 0.9178 - val_loss: 0.5065 - val_acc: 0.8110 Epoch 4/15
25000/25000 [==============================] - 90s 4ms/step - loss: 0.1394
- acc: 0.9495 - val_loss: 0.6046 - val_acc: 0.8146 Epoch 5/15
25000/25000 [==============================] - 90s 4ms/step - loss: 0.0973
- acc: 0.9652 - val_loss: 0.5969 - val_acc: 0.8147 Epoch 6/15
25000/25000 [==============================] - 98s 4ms/step - loss: 0.0759
- acc: 0.9730 - val_loss: 0.6368 - val_acc: 0.8208 Epoch 7/15
25000/25000 [==============================] - 95s 4ms/step - loss: 0.0578
- acc: 0.9811 - val_loss: 0.6657 - val_acc: 0.8184 Epoch 8/15
25000/25000 [==============================] - 97s 4ms/step - loss: 0.0448
- acc: 0.9850 - val_loss: 0.7452 - val_acc: 0.8136 Epoch 9/15
25000/25000 [==============================] - 95s 4ms/step - loss: 0.0324
- acc: 0.9894 - val_loss: 0.7616 - val_acc: 0.8162Epoch 10/15
25000/25000 [==============================] - 100s 4ms/step - loss: 0.0247
- acc: 0.9922 - val_loss: 0.9654 - val_acc: 0.8148 Epoch 11/15
25000/25000 [==============================] - 99s 4ms/step - loss: 0.0169
- acc: 0.9946 - val_loss: 1.0013 - val_acc: 0.8104 Epoch 12/15
25000/25000 [==============================] - 90s 4ms/step - loss: 0.0154
- acc: 0.9948 - val_loss: 1.0316 - val_acc: 0.8100 Epoch 13/15
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0113
- acc: 0.9963 - val_loss: 1.1138 - val_acc: 0.8108 Epoch 14/15
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0106
- acc: 0.9971 - val_loss: 1.0538 - val_acc: 0.8102 Epoch 15/15
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0090
- acc: 0.9972 - val_loss: 1.1453 - val_acc: 0.8129
25000/25000 [==============================] - 10s 390us/step
Paso 7: evaluar el modelo
Evaluemos el modelo usando datos de prueba.
score, acc = model.evaluate(x_test, y_test, batch_size = 32)
print('Test score:', score)
print('Test accuracy:', acc)
La ejecución del código anterior generará la siguiente información:
Test score: 1.145306069601178
Test accuracy: 0.81292
Keras - Aplicaciones
El módulo de aplicaciones de Keras se utiliza para proporcionar un modelo previamente entrenado para redes neuronales profundas. Los modelos de Keras se utilizan para la predicción, la extracción de características y el ajuste fino. Este capítulo explica en detalle las aplicaciones de Keras.
Modelos pre-entrenados
El modelo entrenado consta de dos partes: modelo de arquitectura y modelo de pesos. Los pesos del modelo son archivos grandes, por lo que tenemos que descargar y extraer la función de la base de datos de ImageNet. Algunos de los modelos populares previamente entrenados se enumeran a continuación,
- ResNet
- VGG16
- MobileNet
- InceptionResNetV2
- InceptionV3
Cargando un modelo
Los modelos pre-entrenados de Keras se pueden cargar fácilmente como se especifica a continuación:
import keras
import numpy as np
from keras.applications import vgg16, inception_v3, resnet50, mobilenet
#Load the VGG model
vgg_model = vgg16.VGG16(weights = 'imagenet')
#Load the Inception_V3 model
inception_model = inception_v3.InceptionV3(weights = 'imagenet')
#Load the ResNet50 model
resnet_model = resnet50.ResNet50(weights = 'imagenet')
#Load the MobileNet model mobilenet_model = mobilenet.MobileNet(weights = 'imagenet')
Una vez que se carga el modelo, podemos usarlo inmediatamente con fines de predicción. Revisemos cada modelo previamente entrenado en los próximos capítulos.
Predicción en tiempo real usando el modelo ResNet
ResNet es un modelo previamente entrenado. Está entrenado usando ImageNet . Pesos de modelo ResNet previamente entrenados en ImageNet . Tiene la siguiente sintaxis:
keras.applications.resnet.ResNet50 (
include_top = True,
weights = 'imagenet',
input_tensor = None,
input_shape = None,
pooling = None,
classes = 1000
)
Aquí,
include_top se refiere a la capa completamente conectada en la parte superior de la red.
weights consulte la formación previa en ImageNet.
input_tensor hace referencia al tensor de Keras opcional para usar como entrada de imagen para el modelo.
input_shapese refiere a la tupla de forma opcional. El tamaño de entrada predeterminado para este modelo es 224x224.
classes Consulte el número opcional de clases para clasificar imágenes.
Entendamos el modelo escribiendo un ejemplo simple:
Paso 1: importar los módulos
Carguemos los módulos necesarios como se especifica a continuación:
>>> import PIL
>>> from keras.preprocessing.image import load_img
>>> from keras.preprocessing.image import img_to_array
>>> from keras.applications.imagenet_utils import decode_predictions
>>> import matplotlib.pyplot as plt
>>> import numpy as np
>>> from keras.applications.resnet50 import ResNet50
>>> from keras.applications import resnet50
Paso 2: seleccione una entrada
Elijamos una imagen de entrada, Lotus como se especifica a continuación -
>>> filename = 'banana.jpg'
>>> ## load an image in PIL format
>>> original = load_img(filename, target_size = (224, 224))
>>> print('PIL image size',original.size)
PIL image size (224, 224)
>>> plt.imshow(original)
<matplotlib.image.AxesImage object at 0x1304756d8>
>>> plt.show()
Aquí, hemos cargado una imagen. (banana.jpg) y lo mostró.
Paso 3: convierte imágenes en una matriz NumPy
Convirtamos nuestra entrada, Banana en la matriz NumPy, de modo que se pueda pasar al modelo con fines de predicción.
>>> #convert the PIL image to a numpy array
>>> numpy_image = img_to_array(original)
>>> plt.imshow(np.uint8(numpy_image))
<matplotlib.image.AxesImage object at 0x130475ac8>
>>> print('numpy array size',numpy_image.shape)
numpy array size (224, 224, 3)
>>> # Convert the image / images into batch format
>>> image_batch = np.expand_dims(numpy_image, axis = 0)
>>> print('image batch size', image_batch.shape)
image batch size (1, 224, 224, 3)
>>>
Paso 4: predicción del modelo
Introduzcamos nuestra información en el modelo para obtener las predicciones.
>>> prepare the image for the resnet50 model >>>
>>> processed_image = resnet50.preprocess_input(image_batch.copy())
>>> # create resnet model
>>>resnet_model = resnet50.ResNet50(weights = 'imagenet')
>>> Downloavding data from https://github.com/fchollet/deep-learning-models/releas
es/download/v0.2/resnet50_weights_tf_dim_ordering_tf_kernels.h5
102858752/102853048 [==============================] - 33s 0us/step
>>> # get the predicted probabilities for each class
>>> predictions = resnet_model.predict(processed_image)
>>> # convert the probabilities to class labels
>>> label = decode_predictions(predictions)
Downloading data from https://storage.googleapis.com/download.tensorflow.org/
data/imagenet_class_index.json
40960/35363 [==================================] - 0s 0us/step
>>> print(label)
Salida
[
[
('n07753592', 'banana', 0.99229723),
('n03532672', 'hook', 0.0014551596),
('n03970156', 'plunger', 0.0010738898),
('n07753113', 'fig', 0.0009359837) ,
('n03109150', 'corkscrew', 0.00028538404)
]
]
Aquí, el modelo predijo correctamente las imágenes como banana.
Keras - Modelos pre-entrenados
En este capítulo, aprenderemos sobre los modelos entrenados previamente en Keras. Comencemos con VGG16.
VGG16
VGG16es otro modelo previamente entrenado. También está capacitado con ImageNet. La sintaxis para cargar el modelo es la siguiente:
keras.applications.vgg16.VGG16(
include_top = True,
weights = 'imagenet',
input_tensor = None,
input_shape = None,
pooling = None,
classes = 1000
)
El tamaño de entrada predeterminado para este modelo es 224x224.
MobileNetV2
MobileNetV2es otro modelo previamente entrenado. También se entrena uingImageNet.
La sintaxis para cargar el modelo es la siguiente:
keras.applications.mobilenet_v2.MobileNetV2 (
input_shape = None,
alpha = 1.0,
include_top = True,
weights = 'imagenet',
input_tensor = None,
pooling = None,
classes = 1000
)
Aquí,
alphacontrola el ancho de la red. Si el valor es inferior a 1, disminuye el número de filtros en cada capa. Si el valor es superior a 1, aumenta el número de filtros en cada capa. Si alfa = 1, el número predeterminado de filtros del papel se utiliza en cada capa.
El tamaño de entrada predeterminado para este modelo es 224x224.
InceptionResNetV2
InceptionResNetV2es otro modelo previamente entrenado. También se entrena usandoImageNet. La sintaxis para cargar el modelo es la siguiente:
keras.applications.inception_resnet_v2.InceptionResNetV2 (
include_top = True,
weights = 'imagenet',
input_tensor = None,
input_shape = None,
pooling = None,
classes = 1000)
Este modelo se puede construir tanto con el formato de datos 'channels_first' (canales, alto, ancho) como con el formato de datos 'channels_last' (alto, ancho, canales).
El tamaño de entrada predeterminado para este modelo es 299x299.
InceptionV3
InceptionV3es otro modelo previamente entrenado. También se entrena uingImageNet. La sintaxis para cargar el modelo es la siguiente:
keras.applications.inception_v3.InceptionV3 (
include_top = True,
weights = 'imagenet',
input_tensor = None,
input_shape = None,
pooling = None,
classes = 1000
)
Aquí,
El tamaño de entrada predeterminado para este modelo es 299x299.
Conclusión
Keras es una API de red neuronal muy simple, extensible y fácil de implementar, que se puede usar para construir aplicaciones de aprendizaje profundo con abstracción de alto nivel. Keras es una opción óptima para modelos de inclinación profunda.