Wie visualisieren Sie neuronale Netzwerkarchitekturen?

Wenn man eine Arbeit schreibt / eine Präsentation über ein Thema macht, das sich mit neuronalen Netzwerken befasst, visualisiert man normalerweise die Netzwerkarchitektur.

Was sind gute / einfache Möglichkeiten, um gängige Architekturen automatisch zu visualisieren?

Tensorflow, Keras, MXNet, PyTorch

Wenn das neuronale Netzwerk als Tensorflow-Diagramm angegeben ist, können Sie dieses Diagramm mit TensorBoard visualisieren .

So sieht der MNIST CNN aus:

Sie können Namen / Bereiche (wie "Dropout", "Softmax", "FC1", "Conv1", "Conv2") selbst hinzufügen.

Interpretation

Im Folgenden geht es nur um das linke Diagramm. Ich ignoriere die 4 kleinen Grafiken auf der rechten Hälfte.

Jede Box ist eine Ebene mit Parametern, die gelernt werden können. Zum Schluss fließen die Informationen von unten nach oben. Ellipsen sind Ebenen, die keine gelernten Parameter enthalten.

Die Farbe der Kästchen hat keine Bedeutung.

Ich bin mir nicht sicher, welchen Wert die gestrichelten Kästchen ("Farbverläufe", "Adam", "Speichern") haben.

Ich habe kürzlich ein Tool zum Zeichnen von NN-Architekturen und zum Exportieren von SVG erstellt, NN-SVG

In Caffe können Sie mit caffe / draw.py den NetParameter-Protopuffer zeichnen:

In Matlab können Sie view (net) verwenden.

Keras.js :

Ich würde ASCII-Visualisierungen mit keras-sequential-ascii hinzufügen (Haftungsausschluss: Ich bin der Autor).

Ein kleines Netzwerk für CIFAR-10 (aus diesem Tutorial ) wäre:

       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

Für VGG16 wäre es:

       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

Es gibt ein Open-Source-Projekt namens Netron

Netron ist ein Viewer für Modelle für neuronales Netzwerk, Deep Learning und maschinelles Lernen.

Netron unterstützt ONNX (.onnx, .pb), Keras (.h5, .keras), CoreML (.mlmodel) und TensorFlow Lite (.tflite). Netron bietet experimentelle Unterstützung für Caffe (.caffemodel), Caffe2 (predict_net.pb), MXNet (-symbol.json), TensorFlow.js (model.json, .pb) und TensorFlow (.pb, .meta).

Hier ist noch ein anderer Weg - Dotnets , die Graphviz verwenden und stark von diesem Beitrag von Thiago G. Martins inspiriert sind .

Keras

Das Modul keras.utils.vis_utils bietet Dienstprogrammfunktionen zum Plotten eines Keras-Modells (mithilfe von graphviz).

Im Folgenden wird ein Netzwerkmodell gezeigt, bei dem die erste verborgene Ebene 50 Neuronen aufweist und 104 Eingabevariablen erwartet.

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

Das Python-Paket conxkann Netzwerke mit Aktivierungen mit der Funktion net.picture()zum Erzeugen von SVG-, PNG- oder PIL-Bildern wie folgt visualisieren :

Conx basiert auf Keras und kann Keras-Modelle einlesen. Die Farbzuordnung für jede Bank kann geändert werden und es können alle Bankarten angezeigt werden.

Weitere Informationen finden Sie unter: http://conx.readthedocs.io/en/latest/

Ich habe an einem Drag-and-Drop-Visualizer für neuronale Netze (und mehr) gearbeitet. Hier ist ein Beispiel für eine Visualisierung für eine LeNet-ähnliche Architektur. Modelle mit Fan-Out und Fan-In lassen sich ebenfalls recht einfach modellieren. Sie können die Website unter https://math.mit.edu/ennui/ besuchen.

In R nnetgibt es keine Plotfunktion, aber Code dafür wird hier bereitgestellt .

Alternativ können Sie das neuere und IMHO-bessere Paket verwenden, neuralnetdas eine plot.neuralnetFunktion enthält. Sie können also einfach Folgendes tun:

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

neuralnetwird nicht so oft verwendet, nnetda nnetes viel älter ist und mit r-cran geliefert wird. Es neuralnetverfügt jedoch über mehr Trainingsalgorithmen, einschließlich einer stabilen Backpropagation, die selbst in Paketen wie Tensorflow fehlt, die für die Auswahl von Hyperparametern wesentlich robuster ist und insgesamt über mehr Funktionen verfügt.

Es gibt einige neuartige alternative Bemühungen zur Visualisierung neuronaler Netze.

Bitte beachten Sie diese Artikel:

Atemberaubende KI-Gehirnscans zeigen, was Maschinen sehen, wenn sie neue Fähigkeiten erlernen

In einem KI-Gehirn - Wie sieht maschinelles Lernen aus?

Diese Ansätze sind mehr auf die Visualisierung des neuronalen Netzwerkbetriebs ausgerichtet, die NN-Architektur ist jedoch auch in den resultierenden Diagrammen etwas sichtbar.

Beispiele:

Das ist nicht gerade praktisch für Artikel, aber sehr nützlich, um Leuten zu zeigen, die nicht viel über neuronale Netze wissen, wie ihre Topologie aussehen könnte. Mit dieser Javascript-Bibliothek (Neataptic) können Sie Ihr Netzwerk visualisieren:

Lesen Sie den beliebten Aufsatz " Verständnis neuronaler Netze durch Tiefenvisualisierung", in dem die Visualisierung von Faltungsnetzen behandelt wird. Die Implementierung zeigt nicht nur jede Ebene an, sondern zeigt auch die Aktivierungen, Gewichte, Dekonvolutionen und viele andere Dinge, die im Papier ausführlich diskutiert werden. Der Code ist in caffe'. Das Interessante ist, dass Sie das vortrainierte Modell durch Ihr eigenes ersetzen können.

Tensorspace-JS ist ein fantastisches Tool zur 3D-Visualisierung der Netzwerkarchitektur:

https://tensorspace.org/

und hier ist ein netter Beitrag darüber, wie man ein Programm schreibt:

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

Netscope ist mein alltägliches Werkzeug für Caffe-Modelle.