¿Cómo visualizas las arquitecturas de redes neuronales?

Al escribir un artículo / hacer una presentación sobre un tema que trata sobre redes neuronales, generalmente se visualiza la arquitectura de redes.

¿Cuáles son las formas buenas / simples de visualizar arquitecturas comunes automáticamente?

Tensorflow, Keras, MXNet, PyTorch

Si la red neuronal se proporciona como un gráfico de Tensorflow, puede visualizar este gráfico con TensorBoard .

Así es como se ve el MNIST CNN:

Puede agregar nombres / ámbitos (como "abandono", "softmax", "fc1", "conv1", "conv2") usted mismo.

Interpretación

Lo siguiente es solo sobre el gráfico de la izquierda. Ignoro los 4 pequeños gráficos en la mitad derecha.

Cada cuadro es una capa con parámetros que se pueden aprender. Por inferencia, la información fluye de abajo hacia arriba. Las elipses son capas que no contienen parámetros aprendidos.

El color de las cajas no tiene sentido.

No estoy seguro del valor de las pequeñas cajas discontinuas ("gradientes", "Adam", "guardar").

Recientemente creé una herramienta para dibujar arquitecturas NN y exportar SVG, llamada NN-SVG

En Caffe puedes usar caffe / draw.py para dibujar el protobuffer NetParameter:

En Matlab, puede usar view (net)

Keras.js :

Agregaría visualizaciones ASCII usando keras-sequential-ascii (descargo de responsabilidad: soy el autor).

Una pequeña red para CIFAR-10 (de este tutorial ) sería:

       OPERATION           DATA DIMENSIONS   WEIGHTS(N)   WEIGHTS(%)

           Input   #####     32   32    3
          Conv2D    \|/  -------------------       896     2.1%
            relu   #####     30   30   32
    MaxPooling2D   Y max -------------------         0     0.0%
                   #####     15   15   32
          Conv2D    \|/  -------------------     18496    43.6%
            relu   #####     13   13   64
    MaxPooling2D   Y max -------------------         0     0.0%
                   #####      6    6   64
         Flatten   ||||| -------------------         0     0.0%
                   #####        2304
           Dense   XXXXX -------------------     23050    54.3%
         softmax   #####          10

Para VGG16 sería:

       OPERATION           DATA DIMENSIONS   WEIGHTS(N)   WEIGHTS(%)

          Input   #####      3  224  224
     InputLayer     |   -------------------         0     0.0%
                  #####      3  224  224
  Convolution2D    \|/  -------------------      1792     0.0%
           relu   #####     64  224  224
  Convolution2D    \|/  -------------------     36928     0.0%
           relu   #####     64  224  224
   MaxPooling2D   Y max -------------------         0     0.0%
                  #####     64  112  112
  Convolution2D    \|/  -------------------     73856     0.1%
           relu   #####    128  112  112
  Convolution2D    \|/  -------------------    147584     0.1%
           relu   #####    128  112  112
   MaxPooling2D   Y max -------------------         0     0.0%
                  #####    128   56   56
  Convolution2D    \|/  -------------------    295168     0.2%
           relu   #####    256   56   56
  Convolution2D    \|/  -------------------    590080     0.4%
           relu   #####    256   56   56
  Convolution2D    \|/  -------------------    590080     0.4%
           relu   #####    256   56   56
   MaxPooling2D   Y max -------------------         0     0.0%
                  #####    256   28   28
  Convolution2D    \|/  -------------------   1180160     0.9%
           relu   #####    512   28   28
  Convolution2D    \|/  -------------------   2359808     1.7%
           relu   #####    512   28   28
  Convolution2D    \|/  -------------------   2359808     1.7%
           relu   #####    512   28   28
   MaxPooling2D   Y max -------------------         0     0.0%
                  #####    512   14   14
  Convolution2D    \|/  -------------------   2359808     1.7%
           relu   #####    512   14   14
  Convolution2D    \|/  -------------------   2359808     1.7%
           relu   #####    512   14   14
  Convolution2D    \|/  -------------------   2359808     1.7%
           relu   #####    512   14   14
   MaxPooling2D   Y max -------------------         0     0.0%
                  #####    512    7    7
        Flatten   ||||| -------------------         0     0.0%
                  #####       25088
          Dense   XXXXX ------------------- 102764544    74.3%
           relu   #####        4096
          Dense   XXXXX -------------------  16781312    12.1%
           relu   #####        4096
          Dense   XXXXX -------------------   4097000     3.0%
        softmax   #####        1000

Hay un proyecto de código abierto llamado Netron

Netron es un visor de modelos de redes neuronales, aprendizaje profundo y aprendizaje automático.

Netron admite ONNX (.onnx, .pb), Keras (.h5, .keras), CoreML (.mlmodel) y TensorFlow Lite (.tflite). Netron tiene soporte experimental para Caffe (.caffemodel), Caffe2 (predict_net.pb), MXNet (-symbol.json), TensorFlow.js (model.json, .pb) y TensorFlow (.pb, .meta).

Aquí hay otra forma: dotnets , usando Graphviz , fuertemente inspirado en esta publicación de Thiago G. Martins.

Keras

El módulo keras.utils.vis_utils proporciona funciones de utilidad para trazar un modelo de Keras (usando graphviz)

A continuación se muestra un modelo de red en el que la primera capa oculta tiene 50 neuronas y espera 104 variables de entrada.

plot_model(model, to_file='model.png', show_shapes=True, show_layer_names=True)

El paquete Python conxpuede visualizar redes con activaciones con la función net.picture()para producir imágenes SVG, PNG o PIL como esta:

Conx se basa en Keras y puede leer en los modelos de Keras. El mapa de colores en cada banco se puede cambiar y puede mostrar todos los tipos de bancos.

Se puede encontrar más información en: http://conx.readthedocs.io/en/latest/

He estado trabajando en un visualizador de redes neuronales de arrastrar y soltar (y más). Aquí hay un ejemplo de visualización para una arquitectura similar a LeNet. Los modelos con salida y entrada también se modelan con bastante facilidad. Puede visitar el sitio web en https://math.mit.edu/ennui/

En R, nnetno viene con una función de trazado, pero el código para eso se proporciona aquí .

Alternativamente, puede usar el paquete más reciente e IMHO mejor llamado neuralnetque presenta una plot.neuralnetfunción, por lo que puede hacer lo siguiente:

data(infert, package="datasets")
plot(neuralnet(case~parity+induced+spontaneous, infert))

neuralnetno se usa tanto como nnetporque nnetes mucho más antiguo y se envía con r-cran. Pero neuralnettiene más algoritmos de entrenamiento, incluida la retropropagación resistente que falta incluso en paquetes como Tensorflow, y es mucho más robusta para las opciones de hiperparámetros, y tiene más características en general.

Hay algunos esfuerzos alternativos novedosos en la visualización de redes neuronales.

Por favor vea estos artículos:

Impresionantes 'escaneos cerebrales de IA' revelan lo que las máquinas ven a medida que aprenden nuevas habilidades

Dentro de un 'cerebro' de IA: ¿cómo es el aprendizaje automático?

Estos enfoques están más orientados a visualizar el funcionamiento de la red neuronal, sin embargo, la arquitectura NN también es algo visible en los diagramas resultantes.

Ejemplos:

No es seguro para los documentos, pero es muy útil para mostrar a las personas que no saben mucho sobre redes neuronales cuál es su topología. Esta biblioteca Javascript (Neataptic) le permite visualizar su red:

Puede leer el popular artículo Comprender las redes neuronales a través de la visualización profunda que trata sobre la visualización de redes convolucionales. Su implementación no solo muestra cada capa, sino que también muestra las activaciones, los pesos, las deconvoluciones y muchas otras cosas que se analizan en profundidad en el documento. Su código está adentro caffe'. La parte interesante es que puede reemplazar el modelo pre-entrenado con el suyo.

Tensorspace-JS es una herramienta fantástica para la visualización en 3D de la arquitectura de red:

https://tensorspace.org/

y aquí hay una buena publicación sobre cómo escribir un programa:

https://medium.freecodecamp.org/tensorspace-js-a-way-to-3d-visualize-neural-networks-in-browsers-2c0afd7648a8

Netscope es mi herramienta diaria para los modelos Caffe.