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

262

Pour toute couche Keras ( Layerclasse), quelqu'un peut - il expliquer comment comprendre la différence entre input_shape, units, dim, etc.?

Par exemple, le document dit de unitsspécifier la forme de sortie d'un calque.

Dans l'image du réseau neuronal ci-dessous hidden layer1a 4 unités. Cela se traduit-il directement par l' unitsattribut de l' Layerobjet? Ou bien, unitsdans Keras, la forme de chaque poids dans la couche cachée est-elle égale au nombre d'unités?

Bref, comment comprendre / visualiser les attributs du modèle - en particulier les calques - avec l'image ci-dessous? entrez la description de l'image ici

neural-network deep-learning keras keras-layer tensor épouvantail
la source

Réponses:

412

Unités:

La quantité de "neurones", ou "cellules", ou quoi que la couche ait à 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 loin). 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 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

Ce qui s'écoule entre les couches, ce sont des tenseurs. Les tenseurs peuvent être vus comme des matrices, 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 50x50 pixels en RVB (3 canaux), la forme de vos données d'entrée est (30,50,50,3). Ensuite, votre tenseur de calque d'entrée doit avoir cette forme (voir les détails dans la section "formes en kéros").

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

  • Dense les couches 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 vous utilisez channels_last:(batch_size, imageside1, imageside2, channels)
    • si vous utilisez channels_first:(batch_size, channels, imageside1, imageside2)
  • Utilisation de convolutions 1D et de couches récurrentes (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 la connaître. Vous seul le savez, sur la base 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 les formes et les unités - La forme en sortie

Compte tenu de la forme d'entrée, toutes les autres formes sont le résultat de calculs de couches.

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

Chaque type de calque fonctionne d'une 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 il est toujours basé sur une propriété de couche. (Voir la documentation pour ce que chaque couche produit)

Montrons ce qui se passe avec les calques "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 de sortie.

  • Couche cachée 1: 4 unités, la forme de sortie: (batch_size,4).
  • Couche cachée 2: 4 unités, la forme de sortie: (batch_size,4).
  • Dernière couche: 1 unité, la 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 calque fonctionne d'une certaine manière. Mais les poids seront une matrice capable de transformer la forme d'entrée en forme de 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 nombre de multiplication, tous les nombres formeraient ensemble la matrice de poids.

Formes à Keras

Plus tôt, j'ai donné un exemple de 30 images, 50x50 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 l'exige dans la première couche.

Mais dans cette définition, Keras ignore la première dimension, qui est la taille du lot. Votre modèle doit pouvoir gérer n'importe quelle 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

Facultativement, ou lorsque cela est requis par certains types de modèles, vous pouvez passer 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 de formation à cette taille de lot unique, il ne doit donc ê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 l'avez utilisé input_shape=(50,50,3), lorsque keras vous envoie des messages ou lorsque vous imprimez le résumé du modèle, il s'affichera (None,50,50,3).

La première dimension est la taille du lot, c'est Noneparce qu'elle peut varier en fonction du nombre d'exemples que vous donnez 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 opérez réellement directement sur les tenseurs (à l'intérieur des couches Lambda ou dans la fonction de perte, par exemple), la dimension de la taille du lot sera là.

  • 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 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), selon le type de message qu'il vous envoie.

Faible

Et au final, c'est quoi dim?

Si votre forme d'entrée n'a qu'une seule dimension, vous n'avez pas besoin de la donner comme tuple, vous donnez input_dimcomme un 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:

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

Mais lorsque vous traitez directement avec les tenseurs, dimvous vous référez souvent 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, des Sequentialmodèles ou l'API fonctionnelle Model. Je n'aime pas utiliser le modèle séquentiel, plus tard, vous devrez l'oublier de toute façon 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 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)
Daniel Möller
la source
7
input_shape=Reste une question sur le paramètre: à quelle dimension se réfère la première valeur de l'argument? Je vois des choses comme input_shape=(728, ), donc dans mon esprit, le premier argument fait référence aux colonnes (fixes) et le second aux lignes (libres de varier). Mais comment cela se situe-t-il avec l'ordre de rangée de tableaux principal de Python?
Maxim.K
17
Cette virgule ne crée pas une deuxième dimension. C'est juste une notation python pour créer un tuplequi ne contient qu'un seul élément. input_shape(728,)est le même que batch_input=(batch_size,728). Cela signifie que chaque échantillon a 728 valeurs.
Daniel Möller
@ DanielMöller: pourriez-vous expliquer un peu la différence entre les "éléments d'entrée" et les "dimensions"? Je pense que le graphique ci-dessus avait une couche d'entrée en trois dimensions, ce qui rend dim = 3 , donc je me demande ce qui me manque ici, car je vois que vous écrivez que l'entrée est en 1 dimension ...
Helen
1
Un vecteur a une dimension, mais plusieurs éléments. Il a la forme (n,) ---- Une matrice a deux dimensions, la dimension 0 a m éléments, la dimension 1 a n éléments, totalisant mxn éléments, la forme (m, n). Si vous imaginez un "cube" divisé en petits cubes, chaque petit cube avec des données, ce serait en 3D, avec des éléments mxnxo, une forme (m, n, o).
Daniel Möller
2
@Prince, l'ordre est important. Vous pouvez configurer Keras pour utiliser data_format = 'channels_first'ou data_format='channels_last'. Je recommande d'utiliser toujours les canaux en dernier (Keras par défaut). Il est plus compatible avec toutes les autres couches.
Daniel Möller
11

Clarification de la dimension d'entrée:

Pas une réponse directe, mais je viens de réaliser que le mot Dimension d'entrée pourrait être assez déroutant, alors méfiez-vous:

Il (le mot dimension seul) peut faire référence à:

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

b) Le nombre / longueur total de caractéristiques d'entrée (ou couche d'entrée) (28 x 28 = 784 pour l'image couleur MINST) ou 3000 dans les valeurs de spectre transformées par FFT, ou

"Couche d'entrée / Dimension d'entité d'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, #of Values ​​..) 3 est la réponse.

"N Dimensionalité de l'entrée"

d) La forme d'entrée SPÉCIFIQUE (par exemple (30,50,50,3) dans ces données d'image d'entrée non emballées, ou (30, 250, 3) si Keras non emballé:

Keras a son input_dim se réfère à la dimension de la couche d'entrée / nombre d'entité d'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, est correct et nous vivons dans un monde très déroutant !!

Je trouve que l'un des défis du Machine Learning est de gérer différentes langues ou dialectes et terminologies (comme si vous avez 5 à 8 versions très différentes de l'anglais, alors vous avez besoin de compétences très élevées pour converser avec différents locuteurs). C'est probablement la même chose dans les langages de programmation aussi.

r poon
la source