wake-up-neo.com

Wie berechnet man die Anzahl der Parameter für das neuronale Faltungsnetzwerk?

Ich verwende Lasagne, um eine CNN für den MNIST-Datensatz zu erstellen. Ich folge diesem Beispiel genau: Faltungsneuralnetze und Feature-Extraktion mit Python .

Die derzeit von mir verwendete CNN-Architektur, die keine Dropout-Ebenen enthält, lautet:

NeuralNet(
    layers=[('input', layers.InputLayer),        # Input Layer
            ('conv2d1', layers.Conv2DLayer),     # Convolutional Layer
            ('maxpool1', layers.MaxPool2DLayer), # 2D Max Pooling Layer
            ('conv2d2', layers.Conv2DLayer),     # Convolutional Layer
            ('maxpool2', layers.MaxPool2DLayer), # 2D Max Pooling Layer
            ('dense', layers.DenseLayer),        # Fully connected layer
            ('output', layers.DenseLayer),       # Output Layer
            ],
    # input layer
    input_shape=(None, 1, 28, 28),

    # layer conv2d1
    conv2d1_num_filters=32,
    conv2d1_filter_size=(5, 5),
    conv2d1_nonlinearity=lasagne.nonlinearities.rectify,

    # layer maxpool1
    maxpool1_pool_size=(2, 2),

    # layer conv2d2
    conv2d2_num_filters=32,
    conv2d2_filter_size=(3, 3),
    conv2d2_nonlinearity=lasagne.nonlinearities.rectify,

    # layer maxpool2
    maxpool2_pool_size=(2, 2),


    # Fully Connected Layer
    dense_num_units=256,
    dense_nonlinearity=lasagne.nonlinearities.rectify,

   # output Layer
    output_nonlinearity=lasagne.nonlinearities.softmax,
    output_num_units=10,

    # optimization method params
    update= momentum,
    update_learning_rate=0.01,
    update_momentum=0.9,
    max_epochs=10,
    verbose=1,
    )

Dies gibt die folgenden Layer-Informationen aus:

  #  name      size
---  --------  --------
  0  input     1x28x28
  1  conv2d1   32x24x24
  2  maxpool1  32x12x12
  3  conv2d2   32x10x10
  4  maxpool2  32x5x5
  5  dense     256
  6  output    10

und gibt die Anzahl der lernbaren Parameter aus als 217,706

Ich frage mich, wie diese Zahl berechnet wird? Ich habe eine Reihe von Ressourcen gelesen, darunter das Frage dieses StackOverflow, aber keines verallgemeinert die Berechnung eindeutig.

Wenn möglich, Kann die Berechnung der lernbaren Parameter pro Schicht verallgemeinert werden?

Zum Beispiel Faltungsschicht: Anzahl der Filter x Filterbreite x Filterhöhe.

34
Waddas

Schauen wir uns zunächst an, wie die Anzahl der lernbaren Parameter für jeden einzelnen Layer-Typ berechnet wird, und berechnen Sie dann die Anzahl der Parameter in Ihrem Beispiel.

  • Eingabeebene : Die Eingabeebene liest nur das Eingabebild, daher gibt es hier keine Parameter, die Sie lernen könnten.
  • Faltungsebenen : Betrachten Sie eine Faltungsebene, die l Feature-Maps am Eingang verwendet und k Feature-Maps als hat Ausgabe. Die Filtergröße ist n x m. Zum Beispiel sieht das so aus:

    Visualization of a convolutional layer

    Hier hat die Eingabe l=32 - Feature-Maps als Eingabe, k=64 - Feature-Maps als Ausgabe und die Filtergröße ist n=3 X m=3. Es ist wichtig zu verstehen, dass wir nicht einfach einen 3x3-Filter haben, sondern einen 3x3x32-Filter, da unser Eingang 32 Dimensionen hat. Und wir lernen 64 verschiedene 3x3x32-Filter. Somit ist die Gesamtzahl der Gewichte n*m*k*l. Dann gibt es auch einen Verzerrungsterm für jede Feature-Map, sodass wir eine Gesamtanzahl von Parametern von (n*m*l+1)*k Haben.

  • Pooling-Schichten : Die Pooling-Schichten, z.B. Gehen Sie folgendermaßen vor: "Ersetzen Sie eine 2x2-Nachbarschaft durch ihren Maximalwert". Es gibt also keinen Parameter, den Sie in einer Poolebene lernen könnten.
  • Vollständig verbundene Ebenen : In einer vollständig verbundenen Ebene haben alle Eingabeeinheiten eine separate Gewichtung für jede Ausgabeeinheit. Für n Eingaben und m Ausgaben ist die Anzahl der Gewichte n*m. Außerdem haben Sie für jeden Ausgangsknoten eine Abweichung, sodass Sie sich bei den Parametern (n+1)*m Befinden.
  • Ausgabeebene : Die Ausgabeebene ist eine normale, vollständig verbundene Ebene, also (n+1)*m - Parameter, wobei n ist Anzahl der Eingänge und m ist die Anzahl der Ausgänge.

Die letzte Schwierigkeit ist die erste vollständig verbundene Ebene: Wir kennen die Dimensionalität der Eingabe in diese Ebene nicht, da es sich um eine Faltungsschicht handelt. Um es zu berechnen, müssen wir mit der Größe des Eingabebildes beginnen und die Größe jeder Faltungsschicht berechnen. In Ihrem Fall berechnet Lasagne dies bereits für Sie und meldet die Größen - das macht es uns einfach. Wenn Sie die Größe jeder Ebene selbst berechnen müssen, ist dies etwas komplizierter:

  • Im einfachsten Fall (wie in Ihrem Beispiel) ist die Größe der Ausgabe einer Faltungsschicht input_size - (filter_size - 1), in Ihrem Fall: 28 - 4 = 24. Dies liegt an der Art der Faltung: Wir verwenden z.B Eine 5x5-Nachbarschaft, um einen Punkt zu berechnen. Die beiden äußersten Zeilen und Spalten haben jedoch keine 5x5-Nachbarschaft. Daher können wir für diese Punkte keine Ausgabe berechnen. Deshalb ist unsere Ausgabe 2 * 2 = 4 Zeilen/Spalten kleiner als die Eingabe.
  • Wenn die Ausgabe nicht kleiner als die Eingabe sein soll, kann das Bild mit Nullen aufgefüllt werden (mit dem Parameter pad der Faltungsebene in Lasagne). Z.B. Wenn Sie 2 Zeilen/Spalten mit Nullen um das Bild hinzufügen, beträgt die Ausgabegröße (28 + 4) -4 = 28. Im Falle eines Auffüllens ist die Ausgabegröße input_size + 2*padding - (filter_size -1).
  • Wenn Sie Ihr Bild während der Faltung explizit verkleinern möchten, können Sie einen Schritt definieren, z. stride=2, Dh Sie verschieben den Filter in Schritten von 2 Pixeln. Dann wird der Ausdruck zu ((input_size + 2*padding - filter_size)/stride) +1.

In Ihrem Fall lauten die vollständigen Berechnungen:

  #  name                           size                 parameters
---  --------  -------------------------    ------------------------
  0  input                       1x28x28                           0
  1  conv2d1   (28-(5-1))=24 -> 32x24x24    (5*5*1+1)*32   =     832
  2  maxpool1                   32x12x12                           0
  3  conv2d2   (12-(3-1))=10 -> 32x10x10    (3*3*32+1)*32  =   9'248
  4  maxpool2                     32x5x5                           0
  5  dense                           256    (32*5*5+1)*256 = 205'056
  6  output                           10    (256+1)*10     =   2'570

In Ihrem Netzwerk haben Sie also insgesamt 832 + 9'248 + 205'056 + 2'570 = 217'706 lernbare Parameter. Genau das berichtet Lasagne.

81
hbaderts

aufbauend auf @ hbaderts 'exzellenter Antwort, kann es hilfreich sein, eine Formel für ein I-C-P-C-P-H-O-Netzwerk zu finden (da ich an einem ähnlichen Problem gearbeitet habe).

enter image description here

Auch (1) Faltungsschicht mit 2 × 2 Schritten und (2) Faltungsschicht 1 × 1 Schritt + (max/avg) Pooling mit 2 × 2 Schritten tragen jeweils die gleiche Anzahl von Parametern mit "gleicher" Polsterung bei, wie unten zu sehen ist:

enter image description here

7
Sandipan Dey