Como você visualiza arquiteturas de redes neurais?

Ao escrever um artigo / fazer uma apresentação sobre um tópico sobre redes neurais, geralmente se visualiza a arquitetura das redes.

Quais são as maneiras boas / simples de visualizar arquiteturas comuns automaticamente?

Tensorflow, Keras, MXNet, PyTorch

Se a rede neural for fornecida como um gráfico do Tensorflow, você poderá visualizar esse gráfico com o TensorBoard .

Aqui está como a MNIST CNN se parece:

Você pode adicionar nomes / escopos (como "desistência", "softmax", "fc1", "conv1", "conv2").

Interpretação

O seguinte é apenas sobre o gráfico esquerdo. Ignoro os 4 pequenos gráficos na metade direita.

Cada caixa é uma camada com parâmetros que podem ser aprendidos. Por inferência, as informações fluem de baixo para cima. Elipses são camadas que não contêm parâmetros aprendidos.

A cor das caixas não tem um significado.

Não tenho certeza do valor das pequenas caixas tracejadas ("gradientes", "Adam", "salvar").

Recentemente, criei uma ferramenta para desenhar arquiteturas NN e exportar SVG, chamada NN-SVG

No Caffe, você pode usar caffe / draw.py para desenhar o protobuffer do NetParameter:

No Matlab, você pode usar o view (net)

Keras.js :

Eu adicionaria visualizações ASCII usando keras-sequential-ascii (aviso: eu sou o autor).

Uma pequena rede para o CIFAR-10 ( deste tutorial ) seria:

       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 o VGG16, seria:

       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

Existe um projeto de código aberto chamado Netron

Netron é um visualizador de modelos de redes neurais, aprendizado profundo e aprendizado de máquina.

O Netron suporta ONNX (.onnx, .pb), Keras (.h5, .keras), CoreML (.mlmodel) e TensorFlow Lite (.tflite). A Netron tem suporte experimental para Caffe (.caffemodel), Caffe2 (predict_net.pb), MXNet (-symbol.json), TensorFlow.js (model.json, .pb) e TensorFlow (.pb, .meta).

Aqui está outra maneira: dotnets , usando o Graphviz , fortemente inspirado neste post de Thiago G. Martins.

Keras

O módulo keras.utils.vis_utils fornece funções utilitárias para plotar um modelo Keras (usando graphviz)

A seguir, é mostrado um modelo de rede em que a primeira camada oculta possui 50 neurônios e espera 104 variáveis ​​de entrada.

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

O pacote Python conxpode visualizar redes com ativações com a função net.picture()de produzir imagens SVG, PNG ou PIL como esta:

O Conx é construído em Keras e pode ler nos modelos de Keras. O mapa de cores em cada banco pode ser alterado e pode mostrar todos os tipos de bancos.

Mais informações podem ser encontradas em: http://conx.readthedocs.io/en/latest/

Eu tenho trabalhado em um visualizador de rede neural de arrastar e soltar (e mais). Aqui está um exemplo de uma visualização para uma arquitetura do tipo LeNet. Modelos com fan-out e fan-in também são facilmente modelados. Você pode visitar o site em https://math.mit.edu/ennui/

Em R, nnetnão vem com uma função de plotagem, mas o código para isso é fornecido aqui .

Como alternativa, você pode usar o pacote melhor e mais recente chamado IMHO, neuralnetque apresenta uma plot.neuralnetfunção, para que você possa fazer:

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

neuralnetnão é usado tanto quanto nnetporque nneté muito mais antigo e é enviado com r-cran. Mas neuralnetpossui mais algoritmos de treinamento, incluindo retropropagação resistente, que falta mesmo em pacotes como o Tensorflow, e é muito mais robusta às opções de hiperparâmetros e possui mais recursos em geral.

Existem alguns novos esforços alternativos na visualização de redes neurais.

Por favor, veja estes artigos:

Impressionantes 'escaneamentos cerebrais de IA' revelam o que as máquinas veem à medida que aprendem novas habilidades

Dentro de um 'cérebro' da IA ​​- Como é o aprendizado de máquina?

Essas abordagens são mais orientadas para a visualização da operação da rede neural, no entanto, a arquitetura NN também é um pouco visível nos diagramas resultantes.

Exemplos:

Não é por si só bacana para trabalhos, mas é muito útil para mostrar às pessoas que não sabem muito sobre redes neurais como pode ser sua topologia. Esta biblioteca Javascript (Neataptic) permite visualizar sua rede:

Você pode ler o artigo popular Noções básicas sobre redes neurais através de visualização profunda que discute a visualização de redes convolucionais. Sua implementação não apenas exibe cada camada, mas também descreve as ativações, pesos, desconvoluções e muitas outras coisas que são profundamente discutidas no artigo. É o código está em caffe'. A parte interessante é que você pode substituir o modelo pré-treinado pelo seu.

O Tensorspace-JS é uma ferramenta fantástica para visualização 3D da arquitetura de rede:

https://tensorspace.org/

e aqui está um bom post sobre como escrever um programa:

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

O Netscope é minha ferramenta diária para os modelos Caffe.