Keras entrée explication: input_shape, units, batch_size, dim, etc

Pour toute couche de keras (classe de Layer ), est-ce que quelqu’un peut expliquer comment comprendre la différence entre input_shape , units , dim , etc.? Par exemple, le document indique que les units spécifient la forme de sortie d’un calque. Disons en correspondance avec une image d’un neural network comme celui ci-dessous, la hidden layer1 a 4 unités. Est-ce que cela se traduit directement par l’atsortingbut units de l’object Layer ou est-ce que la forme de chaque poids dans le calque masqué est égale au nombre d’unités?

En bref, comment comprendre / visualiser les atsortingbuts du modèle en particulier les couches, comme on le ferait avec l’image donnée? entrer la description de l'image ici

Unités:

La quantité de “neurones” ou “cellules”, ou ce que la couche contient à l’intérieur.

C’est une propriété de chaque couche, et oui, elle est liée à la forme de 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 les conséquences de la configuration du modèle. Les formes sont des tuples 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 la troisième, totalisant 30 * 4 * 10 = 1200 éléments ou nombres.

La forme d’entrée

Quels stream entre les couches sont des tenseurs. Les tenseurs peuvent être vus comme des masortingces, avec des formes.

Dans 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 50×50 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 les détails dans la section “formes dans keras”).

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

  • Dense couches Dense nécessitent des entrées comme (batch_size, input_size)
    • ou (batch_size, optional,...,optional, input_size)
  • Les couches convolutives 2D ont besoin d’entrées comme:
    • si using channels_last : (batch_size, imageside1, imageside2, channels)
    • si using channels_first : (batch_size, channels, imageside1, imageside2)
  • Les convolutions 1D et les couches récurrentes utilisent (batch_size, sequence_length, features)

Maintenant, la forme d’entrée est la seule que vous devez définir, car votre modèle ne peut pas le savoir. Vous seul le savez, en fonction de 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 formes et unités – La forme de sortie

Compte tenu de la forme d’entrée, toutes les autres formes résultent de calculs de calques.

Les “unités” de chaque couche définiront la forme de sortie (la forme du tenseur produit par le calque et qui sera l’entrée du calque suivant).

Chaque type de couche fonctionne de manière particulière. Les couches denses ont une forme de sortie basée sur les “unités”, les couches convolutives ont une forme de sortie basée sur les “filtres”. Mais il est toujours basé sur certaines propriétés de la couche. (Voir la documentation pour savoir ce que chaque couche produit)

Montrons ce qui se passe avec les couches “Dense”, qui est le type montré 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 de sortie.

  • Couche cachée 1: 4 unités, forme de sortie: (batch_size,4) .
  • Couche cachée 2: 4 unités, forme de sortie: (batch_size,4) .
  • Dernière couche: 1 unité, forme de sortie: (batch_size,1) .

Poids

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

Dans une couche dense, les poids multiplient toutes les entrées. C’est une masortingce 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 formeraient la masortingce de poids.

Formes à Keras

Auparavant, j’ai donné un exemple de 30 images, 50×50 pixels et 3 canaux, ayant une forme d’entrée de (30,50,50,3) .

Comme la forme d’entrée est la seule que vous devez définir, Keras le demandera dans la première couche.

Mais dans cette définition, Keras ignore la première dimension, à savoir la taille du lot. Votre modèle doit pouvoir gérer toute taille de lot, vous ne définissez donc que les autres dimensions:

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

En option, ou lorsque certains types de modèles l’exigent, 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, de sorte qu’il ne doit être utilisé que lorsque cela est vraiment nécessaire.

Dans les deux cas, 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 numéro que vous avez défini apparaîtra au lieu de None )

En outre, dans les travaux avancés, lorsque vous opérez directement sur les tenseurs (dans les couches Lambda ou dans la fonction de perte, par exemple), la dimension de la taille du lot sera présente.

  • Ainsi, lors de la définition de la forme d’entrée, vous ignorez la taille du lot: input_shape=(50,50,3)
  • Lorsque vous effectuez des opérations directement sur les 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) , selon le type de message qui vous est (30,50,50,3) .

Faible

Et à la fin, qu’est-ce qui est dim ?

Si votre forme d’entrée n’a qu’une seule dimension, vous n’avez pas besoin de la donner en tant que tuple, vous input_dim comme un nombre scalaire.

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

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

Mais lorsque l’on se penche directement sur les tenseurs, souvent, les dimensionnements font référence au nombre de dimensions d’un tenseur. Par exemple, un tenseur de 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 le Model API fonctionnel. Je n’aime pas utiliser le modèle séquentiel, plus tard vous devrez l’oublier car vous voudrez des modèles avec des twigs.

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 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 les tailles de lot lors de la définition des calques:

  • inpTensor: (None,3)
  • hidden1Out: (None,4)
  • hidden2Out: (None,4)
  • finalOut: (None,1)

Dimension d’entrée clarifiée:

Pas une réponse directe, mais je me suis juste rendu compte que le mot Input Dimension pouvait être assez déroutant, alors méfiez-vous:

Il (le mot dimension seul) peut se référer à:

a) La dimension des données d’entrée (ou stream) telles que le n ° N des axes du capteur pour transmettre le signal de la série temporelle, ou le canal de couleur RVB (3): mot suggéré => “Dimension InputStream”

b) le nombre / la longueur totale des entités en entrée (ou couche d’entrée) (28 x 28 = 784 pour l’image couleur MINST) ou 3 000 dans les valeurs spectrales transformées en FFT, ou

“Dimension de l’entité entrée / couche d’entrée”

c) La dimensionnalité (nombre de dimensions) de l’entrée (typiquement 3D, comme prévu dans Keras LSTM) ou (#RowofSamples, # de Senors, # de valeurs ..) 3 est la réponse.

“N Dimensionnalité de l’entrée”

d) La forme d’entrée SPECIFIQUE (par exemple, (30,50,50,3) dans cette donnée d’image d’entrée non emballée, ou (30, 250, 3) si elle est non emballée:

Keras a son input_dim qui fait référence à la dimension de la couche d’entrée / du 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 s’agit du temps total

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

Je trouve que l’un des défis de Machine Learning est de traiter différents langages ou dialectes et terminologies (comme si vous aviez 5 à 8 versions très différentes de l’anglais, vous devez maîsortingser très bien les différents intervenants). C’est probablement la même chose dans les langages de programmation.