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?
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?
Respostas:
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").
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 conx
pode 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, nnet
nã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, neuralnet
que apresenta uma plot.neuralnet
função, para que você possa fazer:
data(infert, package="datasets")
plot(neuralnet(case~parity+induced+spontaneous, infert))
neuralnet
não é usado tanto quanto nnet
porque nnet
é muito mais antigo e é enviado com r-cran. Mas neuralnet
possui 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:
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:
e aqui está um bom post sobre como escrever um programa:
O Netscope é minha ferramenta diária para os modelos Caffe.