web-dev-qa-db-fra.com

Explication de l'entrée Keras: input_shape, unités, batch_size, dim, etc.

Quel que soit le calque Keras (Layer classe), quelqu'un peut-il expliquer comment comprendre la différence entre input_shape, units, dim, etc.?

Par exemple, le document indique que units spécifie la forme de sortie d'un calque.

Dans l'image du réseau neuronal ci-dessous, hidden layer1 a 4 unités. Est-ce que cela se traduit directement par l'attribut units de l'objet Layer? Ou bien units dans Keras correspond-il à la forme de chaque poids de la couche masquée multiplié par le nombre d'unités?

En bref, comment comprendre/visualiser les attributs du modèle - en particulier les calques - avec l'image ci-dessous? enter image description here

neural-networkdeep-learningkeraskeras-layertensor
166
scarecrow

Unités:

La quantité de "neurones", ou "cellules", ou ce que la couche a à l'intérieur.

C'est une propriété de chaque couche, et oui, elle est liée à la forme de la sortie (comme nous le verrons plus tard). Dans votre image, à l'exception du calque d'entrée, qui est conceptuellement différent des autres calques, vous avez:

  • Couche cachée 1: 4 unités (4 neurones)
  • Couche cachée 2: 4 unités
  • Dernière couche: 1 unité

Formes

Les formes sont des conséquences de la configuration du modèle. Les formes sont des nuplets représentant le nombre d'éléments d'un tableau ou d'un tenseur dans chaque dimension.

Ex: une forme (30,4,10) signifie un tableau ou un tenseur à 3 dimensions, contenant 30 éléments dans la première dimension, 4 dans la seconde et 10 dans le troisième, totalisant 30 * 4 * 10 = 1200 éléments ou nombres.

La forme d'entrée

Ce qui coule entre les couches sont des tenseurs. Les tenseurs peuvent être vus comme des matrices, avec des formes.

En keras, la couche d’entrée elle-même n’est pas une couche, mais un tenseur. C'est le tenseur de départ que vous envoyez à la première couche cachée. Ce tenseur doit avoir la même forme que vos données d’entraînement.

Exemple: Si vous avez 30 images de 50x50 pixels en RVB (3 canaux), la forme de vos données d'entrée est (30,50,50,3). Ensuite, votre tenseur de couche d’entrée doit avoir cette forme (voir la section "Formes en keras").

Chaque type de couche nécessite l’entrée avec un certain nombre de dimensions:

  • Les couches Dense nécessitent des entrées telles que (batch_size, input_size)
    • ou (batch_size, optional,...,optional, input_size)
  • Les couches convolutives 2D nécessitent des entrées telles que:
    • si vous utilisez channels_last: (batch_size, imageside1, imageside2, channels)
    • si vous utilisez channels_first: (batch_size, channels, imageside1, imageside2)
  • Les convolutions 1D et les couches récurrentes utilisent (batch_size, sequence_length, features)

À présent, la forme en entrée est la seule que vous devez définir, car votre modèle ne peut pas la connaître. Seulement vous le savez, basé sur vos données d'entraînement.

Toutes les autres formes sont calculées automatiquement en fonction des unités et des particularités de chaque couche.

Relation entre les formes et les unités - La forme de sortie

Étant donné la forme en entrée, toutes les autres formes sont des résultats de calculs de couches.

Les "unités" de chaque couche définiront la forme de sortie (la forme du tenseur produite par la couche et qui sera l’entrée de la couche suivante).

Chaque type de couche fonctionne de manière particulière. Les couches denses ont une forme de sortie basée sur des "unités", les couches convolutives ont une forme de sortie basée sur des "filtres". Mais c'est toujours basé sur une propriété de couche. (Voir la documentation pour les résultats de chaque couche)

Montrons ce qui se passe avec les couches "denses", qui est le type indiqué dans votre graphique.

Une couche dense a une forme de sortie de (batch_size,units). Donc, oui, les unités, la propriété du calque, définissent également la forme en sortie.

  • Couche masquée 1: 4 unités, forme en sortie: (batch_size,4).
  • Couche masquée 2: 4 unités, forme en sortie: (batch_size,4).
  • Dernier calque: 1 unité, forme en sortie: (batch_size,1).

Poids

Les poids seront entièrement calculés automatiquement en fonction des formes en entrée et en sortie. Encore une fois, chaque type de couche fonctionne d'une certaine manière. Mais les poids seront une matrice capable de transformer la forme en entrée en la forme en sortie par une opération mathématique.

Dans une couche dense, les poids multiplient toutes les entrées. C'est une matrice avec une colonne par entrée et une ligne par unité, mais ce n'est souvent pas important pour les travaux de base.

Dans l'image, si chaque flèche avait un numéro de multiplication, tous les nombres ensemble formeraient la matrice de pondération.

Formes à Keras

Plus tôt, j'ai donné un exemple de 30 images, 50x50 pixels et 3 canaux, ayant une forme en entrée de (30,50,50,3).

Comme la forme en entrée est la seule à définir, Keras l'exige dans le premier calque.

Mais dans cette définition, Keras ignore la première dimension, qui est la taille du lot. Votre modèle doit pouvoir traiter n’importe quelle taille de lot. Vous ne devez donc définir que les autres dimensions:

input_shape = (50,50,3)
    #regardless of how many images I have, each image has this shape

De manière facultative, ou lorsque cela est requis par certains types de modèles, vous pouvez transmettre la forme contenant la taille du lot via batch_input_shape=(30,50,50,3) ou batch_shape=(30,50,50,3). Cela limite vos possibilités d’entraînement à cette taille de lot unique; il ne doit donc être utilisé que lorsque cela est vraiment nécessaire.

Quelle que soit la méthode choisie, les tenseurs du modèle auront la dimension du lot.

Ainsi, même si vous avez utilisé input_shape=(50,50,3), lorsque keras vous envoie des messages ou lorsque vous imprimez le résumé du modèle, il affiche (None,50,50,3).

La première dimension est la taille du lot, elle est None car elle peut varier en fonction du nombre d’exemples donnés pour la formation. (Si vous avez défini explicitement la taille du lot, le nombre que vous avez défini apparaîtra à la place de None)

De plus, dans les travaux avancés, lorsque vous agissez directement sur les tenseurs (dans les couches Lambda ou dans la fonction de perte, par exemple), la dimension de la taille du lot est présente.

  • Ainsi, lorsque vous définissez la forme en entrée, vous ignorez la taille du lot: input_shape=(50,50,3)
  • Lorsque vous effectuez des opérations directement sur des tenseurs, la forme sera à nouveau (30,50,50,3)
  • Lorsque keras vous envoie un message, la forme sera (None,50,50,3) ou (30,50,50,3), en fonction du type de message qu'il vous envoie.

Faible

Et à la fin, qu'est-ce que dim?

Si votre forme d'entrée n'a qu'une seule dimension, vous n'avez pas besoin de la donner sous forme de tuple, vous donnez input_dim sous forme de nombre scalaire.

Ainsi, dans votre modèle, où votre couche d'entrée comporte 3 éléments, vous pouvez utiliser l'un de ces deux éléments:

  • input_shape=(3,) - La virgule est nécessaire lorsque vous n'avez qu'une seule dimension
  • input_dim = 3

Mais lorsque vous travaillez directement avec les tenseurs, dim fera souvent référence au nombre de dimensions d’un tenseur. Par exemple, un tenseur avec une forme (25,10909) a 2 dimensions.

Définir votre image dans Keras

Keras a deux façons de le faire, les modèles Sequential ou l'API fonctionnelle Model. Je n'aime pas utiliser le modèle séquentiel, vous devrez l’oublier de toute façon plus tard, car vous voudrez des modèles avec des branches.

PS: ici, j'ai ignoré d'autres aspects, tels que les fonctions d'activation.

Avec le modèle séquentiel :

from keras.models import Sequential  
from keras.layers import *  

model = Sequential()    

#start from the first hidden layer, since the input is not actually a layer   
#but inform the shape of the input, with 3 elements.    
model.add(Dense(units=4,input_shape=(3,))) #hidden layer 1 with input

#further layers:    
model.add(Dense(units=4)) #hidden layer 2
model.add(Dense(units=1)) #output layer

Avec le modèle d'API fonctionnel :

from keras.models import Model   
from keras.layers import * 

#Start defining the input tensor:
inpTensor = Input((3,))   

#create the layers and pass them the input tensor to get the output tensor:    
hidden1Out = Dense(units=4)(inpTensor)    
hidden2Out = Dense(units=4)(hidden1Out)    
finalOut = Dense(units=1)(hidden2Out)   

#define the model's start and end points    
model = Model(inpTensor,finalOut)

Formes des tenseurs

N'oubliez pas que vous ignorez la taille des lots lors de la définition des couches:

  • inpTensor: (None,3)
  • hidden1Out: (None,4)
  • hidden2Out: (None,4)
  • finalOut: (None,1)
268
Daniel Möller

Dimension d'entrée clarifiée:

Pas une réponse directe, mais je viens de me rendre compte que la dimension de saisie Word pouvait être assez déroutante, alors méfiez-vous:

Elle (la dimension Word uniquement) peut faire référence à:

a) La dimension des données d'entrée (ou du flux) telle que # N des axes du capteur pour transmettre le signal de série temporelle ou le canal de couleur RVB (3): mot suggéré => "Dimension du flux d'entrée"

b) nombre total/longueur des entités en entrée (ou couche en entrée) (28 x 28 = 784 pour l'image couleur MINST) ou 3 000 dans les valeurs de spectre transformées par la méthode FFT, ou

"Couche d'entrée/Dimension de l'entité en entrée"

c) La dimensionnalité (# de dimension) de l'entrée (généralement 3D comme prévu dans Keras LSTM) ou (#RowofSamples, #of Senors, #ofvalues ​​..) 3 est la réponse.

"N dimensionnalité de l'entrée"

d) Le forme d'entrée SPÉCIFIQUE (par exemple (30,50,50,3) dans ces données d'image d'entrée non enveloppées, ou (30, 250, 3) s'il est non enveloppé Keras: =

Les keras dont input_dim fait référence à la dimension de la couche en entrée/au nombre d'entités en entrée

model = Sequential()
model.add(Dense(32, input_dim=784))  #or 3 in the current posted example above
model.add(Activation('relu'))

Dans Keras LSTM, il fait référence au total des pas de temps

Le terme a été très déroutant, correct et nous vivons dans un monde très déroutant !!

Je trouve que l’un des défis de l’apprentissage automatique est de traiter différentes langues ou dialectes et terminologies (par exemple, si vous disposez de 5 à 8 versions très différentes de l’anglais, vous devez disposer de compétences très élevées pour converser avec des interlocuteurs différents). C'est probablement la même chose dans les langages de programmation.

4
r poon