3 Maneras de construir un modelo de Aprendizaje Profundo con Keras y Tensorflow 2.0 en Python

En este artículo veremos 3 formas en la que podemos crear modelos de aprendizaje profundo usando Keras y Tensorflow 2.0. Lo implementaremos usando el lenguaje de programación Python. Si quieres su implementación en R, puedes ir al siguiente enlace.

Para el tercer método es necesario conocer sobre programación orientada a objetos (POO o OOP en inglés). Si no ha programado usando el paradigma POO, no hay problema, puede usar los dos primeros métodos.

Empecemos.

Índice

Preparando los datos

Antes de probar las 3 maneras de construir un modelo de Aprendizaje profundo con Keras y Tensorflow, necesitamos un problema a resolver.

Para esta publicación usaremos el conjunto Fashion MNIST. Este conjunto de datos consiste de imágenes de prendas con su correspondiente clase. El objetivo es entrenar un modelo que pueda predecir, ingresando una imagen, el tipo de prenda que corresponde. La siguiente imagen muestra el diagrama que vamos a desarrollar:

  • Tenemos un conjunto de imágenes.
  • Entrenamos un modelo, en este caso un modelo Red Neuronal Convolucional (CNN en sus siglas en inglés)
  • Usamos el modelo entrenado para predecir la clase que corresponde a imágenes de prendas no vistas.

Empecemos importando las librerías que necesitaremos:

Ahora vamos a descargar el conjunto de datos Fashion MNIST:

El siguiente script grafica una muestra de imágenes junto con su correspondiente clase:

Podemos ver una muestra de 36 imágenes y sus clases.

El siguiente paso es normalizar las imágenes. La normalización ayuda a que nuestro modelo de aprendizaje profundo entrene correctamente (no haya fuga de gradiente) y pueda entrenar rápidamente. En el caso de imágenes la normalización consiste en mantener los valores de la matriz de imágenes en el rango 0-1.

También añadiremos una entrada más a nuestras imágenes ya que se encuentran en escala de grises (la red neuronal convolucional necesita 3 entradas RGB).

Arquitectura del modelo y proceso de evaluación

En esta publicación usaremos la siguiente arquitectura de nuestra red neuronal. Esta arquitectura consta de las siguientes partes:

  • 3 capas convolucionales + Max pooling + Dropout
  • 1 capa densa
  • Dropout
  • Capa de salida softmax

Nuestro modelo consta de 110,474 parámetros que aprenderán usando el conjunto de entrenamiento.

Usaremos la siguiente función para entrenar nuestro modelo:

  • Compilaremos nuestro modelo usando el optimizador Adam.
  • Como función de pérdida usaremos la entropía cruzada multiclase.
  • Como métrica usaremos la precisión.
  • Entrenaremos en el conjunto de entrenamiento y validaremos en el conjunto de prueba.

Listo, ya tenemos todo lo necesario para empezar a probar las distintas formar de construir una red neuronal.

3 formas para construir un modelo con Keras y Tensorflow en Python

Hay tres métodos para construir un modelo de Keras en Tensorflow:

  • Modelo secuencial
  • API funcional
  • Modelo subclase

Modelo secuencial

Tal como dice el nombre, en un modelo secuencial creamos los modelos capa por capa, o paso por paso. Al igual que una secuencia, con la API secuencial, podemos crear en secuencia una serie de capas, donde cada capa solo tiene un tensor de entrada y un tensor de salida.

La imagen siguiente muestra la implementación de una capa convolucional + max pooling + dropout usando modelo secuencial:

Ejemplos de arquitecturas que se pueden crear de manera secuencial:

Si bien un modelo secuencial es fácil de implementar, tiene las siguientes limitaciones:

  • Múltiples entradas y salidas: El enfoque secuencial solo admite una entrada, si necesitamos modelos con múltiples entradas (por ejemplo, si queremos comparar dos o más imágenes), no es posible usar la vía secuencial. Lo mismo sucede si nuestro modelo tiene más de una salida.
  • Alguna capa individual tiene múltiples entradas o salidas: similar al punto anterior, solo que en lugar de tener
  • Compartir capas: supongamos que queremos entrenar una red neuronal siamesa, es decir, que la misma red neuronal pase por dos inputs distintos (imágenes, texto, audio, …), esto no es posible en la api secuencial.

Implementando y probando el modelo secuencial

En Keras podemos crear un modelo secuencial de dos maneras:

Con el método add

Primero empezamos creando nuestro objeto Sequential. Añadimos las capas que necesitamos usando el método .add(). Veamos:

Veamos la línea 4 de la función. Usando el método .add() podemos agregar capas. Dentro de los paréntesis indicamos la capa que queremos agregar. En este caso, estamos agregando una capa convolucional.

Vamos a entrenar el modelo:

La salida de las últimas iteraciones es la siguiente:

La arquitectura y número de parámetros lo podemos ver usando el método summary():

Añadiendo las capas dentro de una lista

En este caso, dentro de la clase Sequential añadimos todas las capas en formato de lista. De esta manera nos ahorramos el tener que añadir el método .add()

Veamos:

Vamos a entrenar el modelo:

La salida de las últimas iteraciones es la siguiente:

La arquitectura y número de parámetros lo podemos ver usando el método summary():

Podemos ver en ambos casos, que el número de parámetros es el mismo 110,474.

API Funcional

La API funcional de keras proporciona una forma más flexible de definir modelos.

Con la API funcional podemos hacer:

  • Crear modelos complejos.
  • Tener múltiples entradas y múltiples salidas.
  • Compartir capas dentro de una arquitectura.

Ejemplos de arquitecturas que se pueden crear con la API funcional:

Implementando y probando la API funcional

Vamos a crear la misma red neuronal usando la API funcional:

Miremos un poco la función:

  • Usamos Input() con la dimensión (shape) para definir la capa de entrada. En este caso usamos como argumento shape=[28, 28, 1]. Lo podemos ver en la línea 3.
  • Cada capa necesita como entrada un tensor y retorna como salida un tensor. Lo podemos ver en la línea 4.
  • Para definir el modelo necesitamos usar la clase Model() y necesita dos argumentos: tensores de entrada y tensores de salida. Lo podemos ver en la línea 25.

Vamos a entrenar el modelo:

La salida de las últimas iteraciones es la siguiente:

La arquitectura y número de parámetros lo podemos ver usando el método summary():

Múltiples entradas y múltiples salidas en API funcional

Los modelos con múltiples entradas y múltiples salidas son buenos casos del uso de la API funcional, veamos algunos ejemplos:

  • Múltiples entradas y una salida:
    • Redes siamesas. Queremos comparar si dos imágenes pertenecen a la misma clase. En este caso, la misma red neuronal pasa por dos entradas. La salida es 1 o 0, donde 1 indica que las imágenes pertenecen a la misma clase y 0 que no.
    • Analizar texto e imágenes. Por ejemplo,
  • Una entrada y múltiples salidas:
    • Predecir de la imagen de un rostro, la edad (salida numérica) y si está sonriendo (salida categórica).
  • Múltiples entradas y múltiples salidas:
    • Predecir, usando como entradas imagen y texto, las salida numérica y categórica.

En una siguiente publicación probaremos distintas arquitecturas usando la API funcional.

API subclase

La última forma de implementar un modelo con Keras y Tensorflow 2.0 se llama Subclassing. Este enfoque requiere que conozcamos los conceptos de programación orientada a objetos (POO o OOP en inglés).

La creación de subclases es totalmente personalizable y nos permite implementar prácticamente cualquier modelo. Sin embargo, es más difícil de utilizar que la API secuencial o la API funcional.

Implementando y probando la API subclase

Comenzamos con la creación de una clase que extiende la clase tf.keras.Model:

Hay dos métodos importantes en la creación subclase:

  • __init__: con este método podemos inicializar los atributos de nuestro modelo, como, por ejemplo, las capas. Podemos agregar argumentos en este método, como, por ejemplo, los filtros de la capa CNN, o, el número de neuronas en la capa final. Lo podemos ver en la línea 3.
  • cal(inputs): luego de definir nuestras capas, en este método se definen las operaciones. Lo podemos ver en la línea 28.

Vamos a entrenar el modelo:

La salida de las últimas iteraciones es la siguiente:

La arquitectura y número de parámetros lo podemos ver usando el método summary():

Conclusión

En esta publicación hemos visto 3 maneras para crear modelos con Keras y Tensorflow 2.0 en Python:

  • Secuencial:
    • Añadiendo capas usando .add
    • Ingresando las capas en una lista
  • Funcional
  • Subclases

Veamos algunas diferencia entre los 3 métodos:

CaracterísticaSecuencialFuncionalSubclase
PersonalizaciónBajaMediaAlta
Dificultad para construirBajaMediaAlta
Compartir capasNoSiSi
Múltiples entradasNoSiSi
Múltiples salidasNoSiSi
Múltiples capasNoSiSi
Adecuado paraPrincipiantesProfesionalesInvestigadores

El código está en el siguiente enlace: https://github.com/Jazielinho/DeepLearningSpecialization/blob/master/Tensorflow/Maneras_crear_modelos/ways_create_tensorflow_models.py

Todo comentario es bienvenido.

close

¡No te pierdas mis últimas publicaciones!

¡No te enviaré spam!

Una respuesta a «3 Maneras de construir un modelo de Aprendizaje Profundo con Keras y Tensorflow 2.0 en Python»

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *