Comment calculer le nombre de paramètres pour le réseau de neurones à convolution?

Je suis l'aide de Lasagne à créer un CNN pour la MNIST dataset. Je suis près à cet exemple: Les Réseaux de Neurones à convolution et l'Extraction de caractéristiques avec Python.

Le CNN de l'architecture, j'ai à l'heure actuelle, qui ne comprend pas tout de décrochage des couches, est:

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,
    )

Ce sorties de la Couche suivante de l'Information:

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

et renvoie le nombre de apprend paramètres 217,706

Je me demande comment ce nombre est calculé? J'ai lu un certain nombre de ressources, y compris ce StackOverflow est question, mais aucun clairement généralise le calcul.

Si possible, pouvez le calcul de la apprend paramètres par couche, être généralisée?

Par exemple, convolutifs couche: nombre de filtres x filtre de largeur x filtre de hauteur.

OriginalL'auteur Waddas | 2017-03-14

59

Regardons d'abord comment le nombre de apprend paramètres est calculée pour chaque type de couche que vous avez, puis de calculer le nombre de paramètres dans votre exemple.
- De la couche d'entrée: Toutes la couche d'entrée n'est de lire l'image d'entrée, donc il n'y a pas de paramètres pour vous apprendre ici.
- Convolutifs couches: Considérons un convolutifs couche qui prend l fonction des cartes à l'entrée, et a k fonction des cartes de sortie. La taille du filtre est n x m. Par exemple, cela va ressembler à ceci:
  
  Ici, l'entrée a l=32 fonction des cartes d'entrée, k=64 fonction des cartes de sortie, et la taille du filtre est n=3 x m=3. Il est important de comprendre, que nous ne nous contentons pas d'avoir un filtre 3x3, mais en fait un 3x3x32 filtre, comme notre entrée a 32 dimensions. Et nous apprenons 64 3x3x32 filtres.
  Ainsi, le nombre total des pondérations est n*m*k*l.
  Ensuite, il y a aussi un biais terme pour chaque fonctionnalité de la carte, nous avons donc un nombre total de paramètres de (n*m*l+1)*k.
- Mise en commun des couches: La mise en commun des couches par exemple, procédez de la manière suivante: "remplacer un 2x2 quartier par sa valeur maximale". Donc, il n'y a pas de paramètre que vous pourriez apprendre en une mise en commun de la couche.
- Entièrement connecté couches: Dans un cadre entièrement connecté couche, toutes les unités d'entrée ont un poids à chaque unité de sortie. Pour n entrées et m sorties, le nombre de poids est n*m. En outre, vous avez un parti pris pour chaque nœud de sortie, de sorte que vous êtes à (n+1)*m paramètres.
- Couche de sortie: La couche de sortie est normale complètement connecté à la couche, de sorte (n+1)*m paramètres, où n est le nombre d'entrées et de m est le nombre de sorties.
La dernière difficulté est la première entièrement connecté couche: nous ne savons pas la dimension de l'entrée de cette couche, comme c'est une convolution de la couche. Pour le calculer, nous devons commencer avec la taille de l'image d'entrée, et de calculer la taille de chaque convolution de la couche. Dans votre cas, Lasagne déjà calcule pour vous et les rapports de la taille, ce qui le rend facile pour nous. Si vous avez de calculer la taille de chaque couche vous-même, c'est un peu plus compliqué:
- Dans le cas le plus simple (comme ton exemple), la taille de la sortie d'une convolution de la couche est input_size - (filter_size - 1), dans votre cas: 28 - 4 = 24. Cela est dû à la nature de la convolution: nous utilisons par exemple un 5x5 quartier pour calculer un point - mais les deux ultrapériphériques de lignes et de colonnes n'ont pas 5x5 quartier, on ne peut donc pas calculer de sortie pour ces points. C'est pourquoi notre sortie est de 2*2=4 lignes/colonnes plus petites que celle de l'entrée.
- Si l'on ne veut pas que la sortie soit plus petit que celui de l'entrée, on peut le zéro de la tablette de l'image (avec le pad paramètre de la convolution de la couche de Lasagne). E. g. si vous ajoutez 2 lignes/colonnes de zéros autour de l'image, la taille de sortie (28+4)-4=28. Ainsi, en cas de remplissage, la taille de sortie est input_size + 2*padding - (filter_size -1).
- Si vous souhaitez explicitement pour sous-échantillonner votre image lors de la convolution, vous pouvez définir une foulée, par exemple stride=2, ce qui signifie que vous placez le filtre dans les étapes de 2 pixels. Ensuite, l'expression devient ((input_size + 2*padding - filter_size)/stride) +1.
Dans votre cas, tous les calculs sont les suivants:
```
  #  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
```
Donc, dans votre réseau, vous avez un total de 832 + 9'248 + 205'056 + 2'570 = 217'706 faciles à apprendre, paramètres, ce qui est exactement ce que la Lasagne rapports.

Super réponse, je vous remercie. Seule chose que je suis encore confus sur la façon dont la convolution couches taille est calculée. Je ne suis pas sûr d'où la 24x24 et 10x10 viennent.
J'ai ajouté plus de détails sur le calcul de la taille de convolution couches - s'il vous plaît laissez-moi savoir si cela aide.
Salut @hbaderts , j'avais une autre question. Basé sur cette table que vous avez ici, le modèle à la taille se réfère à la somme de toutes les tailles ici, correct? Pour CNN, est-il judicieux de comprendre que le modèle taille est inversement proportionnelle au nombre de apprend params? Veuillez voulez-vous prendre un coup d'oeil à stackoverflow.com/questions/43443342/... ?
votre explication est très utile, mais je ne sais pas pourquoi vous traitez le biais d'une 1 dans ((nml+1)*k), si j'ai 16 caractéristiques de sortie, de sorte que le biais sera également 16, n'est-ce pas? nous devons donc ajouter 16 à la formule ci-dessus?
si vous avez 16 caractéristiques de sortie, puis k=16. L'équation est (n*m*l+1)*k, le +1 est à l'intérieur des parenthèses. Ainsi, le +1 est multipliée par 16 trop, donnant n*m*l*16 + 16 pour votre exemple. Cela vous aide?

OriginalL'auteur hbaderts
5

de construction sur le dessus de @hbaderts excellente réponse, tout simplement venu avec une formule pour un I-C-P-C-P-H-O réseau (depuis que je travaille sur un problème similaire), le partage dans la figure ci-dessous, peuvent être utiles.

Aussi, (1) la convolution couche avec 2x2 foulée et (2) la convolution de la couche de 1x1 foulée + (max/avg) la mise en commun avec 2x2 foulée, chacun contribue même nombre de paramètres avec "même" padding, comme on peut le voir ci-dessous:

OriginalL'auteur Sandipan Dey

Vous devez vous connecter pour publier un commentaire.