Comment visualisez-vous les architectures de réseaux de neurones?

Lors de la rédaction d'un article / d'une présentation sur un sujet concernant les réseaux de neurones, on visualise généralement l'architecture du réseau.

Quels sont les moyens bons / simples de visualiser automatiquement les architectures communes?

Tensorflow, Keras, MXNet, PyTorch

Si le réseau de neurones est présenté sous forme de graphique Tensorflow, vous pouvez visualiser ce graphique avec TensorBoard .

Voici à quoi ressemble le MNIST CNN:

Vous pouvez ajouter des noms / champs (comme "dropout", "softmax", "fc1", "conv1", "conv2") vous-même.

Interprétation

Ce qui suit concerne uniquement le graphique de gauche. J'ignore les 4 petits graphiques sur la moitié droite.

Chaque case est une couche avec des paramètres qui peuvent être appris. Pour inférence, l'information circule de bas en haut. Les ellipses sont des couches qui ne contiennent pas de paramètres appris.

La couleur des cases n'a pas de sens.

Je ne suis pas sûr de la valeur des petites boîtes en pointillés ("gradients", "Adam", "enregistrer").

J'ai récemment créé un outil de dessin d'architectures NN et d'exportation SVG, appelé NN-SVG.

Dans Caffe, vous pouvez utiliser caffe / draw.py pour dessiner le protobuffer NetParameter:

Dans Matlab, vous pouvez utiliser la vue (net)

Keras.js :

J'ajouterais des visualisations ASCII à l'aide de keras-sequential-ascii (disclaimer: je suis l'auteur).

Un petit réseau pour CIFAR-10 (tiré de ce tutoriel ) serait:

       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

Pour VGG16, ce serait:

       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

Il y a un projet open source appelé Netron

Netron est un visualiseur de modèles de réseaux de neurones, d'apprentissage en profondeur et d'apprentissage automatique.

Netron prend en charge ONNX (.onnx, .pb), Keras (.h5, .keras), CoreML (.mlmodel) et TensorFlow Lite (.tflite). Netron dispose d'un support expérimental pour Caffe (.caffemodel), Caffe2 (predict_net.pb), MXNet (-symbol.json), TensorFlow.js (model.json, .pb) et TensorFlow (.pb, .meta).

Voici un autre moyen: dotnets , en utilisant Graphviz , fortement inspiré de cet article de Thiago G. Martins.

Keras

Le module keras.utils.vis_utils fournit des fonctions utilitaires permettant de tracer un modèle de Keras (à l'aide de graphviz).

Ce qui suit montre un modèle de réseau selon lequel la première couche cachée contient 50 neurones et attend 104 variables d'entrée.

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

Le paquet Python conxpeut visualiser des réseaux avec des activations avec la fonction net.picture()pour produire des images SVG, PNG ou PIL comme ceci:

Conx est construit sur Keras et peut lire dans les modèles de Keras. La palette de couleurs de chaque banque peut être modifiée et peut afficher tous les types de banque.

Plus d'informations peuvent être trouvées sur: http://conx.readthedocs.io/en/latest/

J'ai travaillé sur un visualiseur de réseau neuronal à glisser et déposer (et plus encore). Voici un exemple de visualisation pour une architecture de type LeNet. Les modèles avec fan-out et fan-in sont également assez faciles à modéliser. Vous pouvez visiter le site Web à l' adresse https://math.mit.edu/ennui/

En R, nnetne vient pas avec une fonction de tracé, mais le code pour cela est fourni ici .

Alternativement, vous pouvez utiliser le meilleur paquet plus récent et meilleur IMHO appelé neuralnetqui comporte une plot.neuralnetfonction, de sorte que vous pouvez simplement faire:

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

neuralnetn'est pas utilisé autant que nnetparce qu'il nnetest beaucoup plus vieux et est livré avec r-cran. Mais neuralneta plus d'algorithmes de formation, y compris la rétropropagation résiliente qui fait défaut, même dans des packages comme Tensorflow, et est beaucoup plus robuste pour les choix d'hyperparamètre, et possède davantage de fonctionnalités.

Il existe quelques nouveaux efforts alternatifs sur la visualisation de réseaux neuronaux.

S'il vous plaît voir ces articles:

De superbes 'analyses du cerveau de l'IA' révèlent ce que les machines voient lorsqu'elles acquièrent de nouvelles compétences

Dans un cerveau d'intelligence artificielle - À quoi ressemble l'apprentissage automatique?

Ces approches sont davantage orientées vers la visualisation du fonctionnement du réseau neuronal. Cependant, l'architecture NN est également visible sur les diagrammes résultants.

Exemples:

Non utile en soi pour les articles, mais très utile pour montrer à des personnes qui ne connaissent pas beaucoup les réseaux de neurones à quoi ressemble leur topologie. Cette bibliothèque Javascript (Neataptic) vous permet de visualiser votre réseau:

Vous pouvez lire le document populaire Comprendre les réseaux de neurones par la visualisation profonde, qui traite de la visualisation des réseaux de convolution. Son implémentation affiche non seulement chaque couche, mais également les activations, les pondérations, les déconvolutions et de nombreuses autres choses discutées en profondeur dans le document. Son code est en caffe'. La partie intéressante est que vous pouvez remplacer le modèle pré-formé par le vôtre.

Tensorspace-JS est un outil fantastique pour la visualisation 3D de l'architecture de réseau:

https://tensorspace.org/

et voici un post intéressant sur la rédaction d'un programme:

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

Netscope est mon outil quotidien pour les modèles Caffe.