3 formas de visualizar fácilmente los modelos de aprendizaje automático de Keras

El viejo cliché “Una imagen vale más que mil palabras” podría ser aún más cierto cuando se trabaja con modelos complejos de aprendizaje automático. A menos que esté bendecido con una memoria fotográfica, puede perder rápidamente la rastreo de la arquitectura del modelo cuando solo lea el código.

Afortunadamente, hay algunas maneras fáciles de visualizar modelos de aprendizaje automático. Esta guía se centra en la visualización de los modelos Keras y utiliza el siguiente modelo (el “modelo de prueba”) para la demostración:

def build_model(pad_len, imu_dim, tof_dim, n_classes):
   def time_sum(x):
      return Okay.sum(x, axis=1)

   def squeeze_last_axis(x):
      return tf.squeeze(x, axis=-1)

   def expand_last_axis(x):
      return tf.expand_dims(x, axis=-1)    
    
   filters_l1 = 64
   kernel_l1 = 3
   filters_l2 = 128
   kernel_l2 = 5
   discount = 8
   pool_size = 2
   drop = 0.3
   wd = 1e-4
    
   inp = Enter(form=(pad_len, imu_dim + tof_dim))
   imu = Lambda(lambda t: t[:, :, :imu_dim])(inp)
   tof = Lambda(lambda t: t[:, :, imu_dim:])(inp)

   # First CNN department
   shortcut_1 = imu
   x1 = Conv1D(filters_l1, kernel_l1, padding="identical", use_bias=False, kernel_regularizer=l2(wd))(imu)
   x1 = BatchNormalization()(x1)
   x1 = Activation("relu")(x1)
   x1 = Conv1D(filters_l1, kernel_l1, padding="identical", use_bias=False, kernel_regularizer=l2(wd))(x1)
   x1 = BatchNormalization()(x1)
   x1 = Activation("relu")(x1)

   ch = x1.form[-1]
   se = GlobalAveragePooling1D()(x1)
   se = Dense(ch//discount, activation="relu")(se)
   se = Dense(ch, activation="sigmoid")(se)
   se = Reshape((1, ch))(se)
   x1 = Multiply()([x1, se])

   if shortcut_1.form[-1] != filters_l1:
      shortcut_1 = Conv1D(filters_l1, 1, padding="identical", use_bias=False, kernel_regularizer=l2(wd))(shortcut_1)
      shortcut_1 = BatchNormalization()(shortcut_1)
    
   x1 = add([x1, shortcut_1])
   x1 = Activation("relu")(x1)
   x1 = MaxPooling1D(pool_size)(x1)
   x1 = Dropout(drop)(x1)

   shortcut_2 = x1
   x1 = Conv1D(filters_l2, kernel_l2, padding="identical", use_bias=False, kernel_regularizer=l2(wd))(x1)
   x1 = BatchNormalization()(x1)
   x1 = Activation("relu")(x1)
   x1 = Conv1D(filters_l2, kernel_l2, padding="identical", use_bias=False, kernel_regularizer=l2(wd))(x1)
   x1 = BatchNormalization()(x1)
   x1 = Activation("relu")(x1)

   ch = x1.form[-1]
   se = GlobalAveragePooling1D()(x1)
   se = Dense(ch//discount, activation="relu")(se)
   se = Dense(ch, activation="sigmoid")(se)
   se = Reshape((1, ch))(se)
   x1 = Multiply()([x1, se])

   if shortcut_2.form[-1] != filters_l2:
      shortcut_2 = Conv1D(filters_l2, 1, padding="identical", use_bias=False, kernel_regularizer=l2(wd))(shortcut_2)
      shortcut_2 = BatchNormalization()(shortcut_2)

   x1 = add([x1, shortcut_2])
   x1 = Activation("relu")(x1)
   x1 = MaxPooling1D(pool_size)(x1)
   x1 = Dropout(drop)(x1)
    
   # Second CNN department
   x2 = Conv1D(filters_l1, kernel_l1, padding="identical", use_bias=False, kernel_regularizer=l2(wd))(tof)
   x2 = BatchNormalization()(x2)
   x2 = Activation("relu")(x2)
   x2 = MaxPooling1D(2)(x2)
   x2 = Dropout(0.2)(x2)
   x2 = Conv1D(filters_l2, kernel_l1, padding="identical", use_bias=False, kernel_regularizer=l2(wd))(x2)
   x2 = BatchNormalization()(x2)
   x2 = Activation("relu")(x2)
   x2 = MaxPooling1D(2)(x2)
   x2 = Dropout(0.2)(x2)    

   merged = Concatenate()([x1, x2])

   xa = Bidirectional(LSTM(128, return_sequences=True, kernel_regularizer=l2(wd)))(merged)
   xb = Bidirectional(GRU(128, return_sequences=True, kernel_regularizer=l2(wd)))(merged)
   xc = GaussianNoise(0.09)(merged)
   xc = Dense(16, activation="elu")(xc)

   x = Concatenate()([xa, xb, xc])
   x = Dropout(0.4)(x)
   rating = Dense(1, activation="tanh")(x)
   rating = Lambda(squeeze_last_axis)(rating)
   weights = Activation("softmax")(rating)
   weights = Lambda(expand_last_axis)(weights)
   context = Multiply()([x, weights])
   x = Lambda(time_sum)(context)

   x = Dense(256, use_bias=False, kernel_regularizer=l2(wd))(x)
   x = BatchNormalization()(x)
   x = Activation("relu")(x)
   x = Dropout(0.5)(x)

   x = Dense(128, use_bias=False, kernel_regularizer=l2(wd))(x)
   x = BatchNormalization()(x)
   x = Activation("relu")(x)
   x = Dropout(0.3)(x)

   out = Dense(n_classes, activation="softmax", kernel_regularizer=l2(wd))(x)
   return Mannequin(inp, out)

Como puede ver, el modelo anterior es razonablemente complejo. Se utiliza para aprender patrones de la unidad de medición intertial (“IMU”) y otros datos del sensor. Para ser claros, no lo construí. Se hace referencia desde este cuaderno de Kaggle. Como observará, la definición del modelo en el cuaderno authentic utiliza objetos personalizados para encapsular cierta lógica que se repite en el diseño del modelo. Elegí eliminar esos objetos y la explicidad Definir la lógica “en línea” para ver mejor la estructura completa del modelo en mi implementación ligeramente modificada.

Esta guía analiza las siguientes 3 herramientas de visualización:

1. Netron

2. El Visualkeras Paquete de Python

3. Tabla tensor

1. Uso de Netron para visualizar su modelo Keras

Netron es posiblemente la herramienta de visualización más easy disponible. Simplemente necesita hacer clic en el Modelo abierto … Botón en la página de inicio y luego seleccione el modelo que desea visualizar. Aquí hay una visualización de las primeras capas del modelo de prueba:

Una vez que se carga el modelo, puede hacer clic en los nodos en el gráfico del modelo para ver sus propiedades:

Puede exportar el gráfico de modelo en .png y .svg Formatos haciendo clic en el icono del menú principal y seleccionando la opción de exportación apropiada.

2. Usando visualkeras Para visualizar su modelo Keras

El visualkeras El paquete Python también es muy fácil de usar y ofrece una forma conveniente de visualizar un modelo antes de la capacitación. Puede instalar el paquete para su proyecto de aprendizaje automático utilizando pip:

pip set up visualkeras

El siguiente código Python demuestra el uso básico del paquete:

# [Imports for your Keras model here...]
import visualkeras

# [Utility function to build your Keras model...]
def build_model(model_params):
   # [Your model definition here...]

# [Build the model...]
mannequin = build_model(model_params)

# [Visualize the model...]
visualkeras.graph_view(mannequin).present()

El graph_view El método produce el siguiente gráfico de las primeras capas del modelo de prueba:

El paquete también ofrece un layered_view Método que produce un gráfico de las capas modelo distinguidas por tipo y tamaño:

visualkeras.layered_view(mannequin, legend=True).present()

Como se ve, pasando True hacia legend El parámetro genera una leyenda que describe cada capa:

Una ventaja del visualkeras El paquete es el management que ofrece sobre cómo se muestran los gráficos. Puede revisar los parámetros utilizados para modificar la salida gráfica en la página de documentación del paquete.

3. Usando Tabla tensor Para visualizar un modelo keras

Tabla tensor es una opción conveniente para la visualización de un modelo keras ya que está instalado junto con Flujo tensor. Con un poco de “masaje”, también es posible usar Tabla tensor Para visualizar la estructura de un modelo antes del entrenamiento.

3.1 Instalación del jupyter-tensorboard Paquete

Esta sección usa Tabla tensor dentro del contexto de un Cuaderno de jupyter. Esto requiere la instalación del jupyter-tensorboard Paquete, que a su vez tiene un par de dependencias. Use los siguientes pasos para instalar jupyter-tensorboard:

1. Instalar el jupyter paquete usando pip set up jupyer.

2. Usar el pip set up --upgrade pocket book==6.4.12 ordenar degradar el pocket book paquete que se instaló con el jupyter Proceso de instalación de paquetes. La versión del pocket book Paquete instalado con jupyter que es 7.4.5 A partir de este artículo no es appropriate con jupyter-tensorboard. Este paso de rebaja instala una versión del pocket book paquete que es appropriate con jupyter-tensorboard. Vea este artículo de Stackoverflow para obtener más información.

3. Instalar el jupyter-tensorboard paquete usando pip set up jupyter-tensorboard.

3.2 Configuración de un cuaderno Jupyter para visualizar su modelo Keras

Como se mencionó anteriormente, puede visualizar un modelo Keras en Tabla tensor antes de entrenarlo. El siguiente código de cuaderno Jupyter demuestra cómo hacerlo utilizando el modelo de prueba de la sección introductoria:

# Cell 1: Imports
import tensorflow as tf
from tensorflow.keras.fashions import Mannequin, load_model
from tensorflow.keras.layers import (
   Enter, Conv1D, BatchNormalization, Activation, add, MaxPooling1D, Dropout,
   Bidirectional, LSTM, GlobalAveragePooling1D, Dense, Multiply, Reshape,
   Lambda, Concatenate, GRU, GaussianNoise
)
from tensorflow.keras.regularizers import l2
from tensorflow.keras import backend as Okay

# Cell 2: Set logs listing
LOG_DIR = "logs"

# Cell 3: Utility perform to construct mannequin
# [`build-model` function for test model from introductory section here...]

# Cell 4: Construct the mannequin
mannequin = build_model(398, 12, 335, 18)

# Cell 5: Compile the mannequin
mannequin.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"])

# Cell 6: Create a TensorBoard callback
tensorboard_callback = tf.keras.callbacks.TensorBoard(
   log_dir=LOG_DIR,
   histogram_freq=1,
   write_graph=True,
   profile_batch=0 # Disable profiling
)

# Cell 7: Create dummy `x` and `y` coaching inputs that match mannequin enter and output shapes
dummy_x_input = tf.random.regular((1, 398, 347)) # Batch measurement 1, enter form (398,347)
dummy_y_input = tf.random.regular((1, 18)) # Batch measurement 1, enter form (18, )

# Cell 8: "Practice" the mannequin for zero epochs to create a conceptual graph of the mannequin
mannequin.match(dummy_x_input, dummy_y_input, epochs=0, batch_size=1, callbacks=[tensorboard_callback])

# Cell 9: Load the TensorBoard pocket book extension
%load_ext tensorboard

# Cell 10: Launch TensorBoard
%tensorboard --logdir $LOG_DIR --host localhost

Si ejecuta el código de cuaderno Jupyter anterior, la última celda debe emitir Launching TensorBoard. Una vez que se completa la ejecución de la celda, puede navegar a para ver el Tabla tensor panel.

3.3 Visualización de su modelo Keras con TensorBoard

Tensorboard debe abrirse automáticamente al Gráficos panel. Si no es así, puede hacer clic en el Gráficos opción de menú o puede seleccionar alternativamente Gráficos Desde el menú desplegable.

Desde Gráficos Ver, seleccionar Gráfico conceptual para ver la estructura de su modelo. Inicialmente debe ver un solo nodo que represente todo el modelo. Haga doble clic en el nodo para ver la estructura de sub-gráfico.

Puede hacer doble clic en nodos individuales dentro de la estructura de sub-gráfico para ver sus propiedades. TensorBoard también le permite exportar el gráfico del modelo en .png formato.

Conclusión

Cada método de visualización discutido anteriormente tiene sus professionals y contras. Netron es extremadamente fácil de usar con modelos capacitados, mientras que visualkeras Podría decirse que es la herramienta más fácil de usar con modelos no entrenados. Como se ve, Tensorboard también se puede usar con modelos no entrenados, pero requiere un poco más de trabajo para configurar correctamente.