Partager via

Convolution

  • Article
Convolution (w, input,
             {kernel dimensions}, 
             mapDims = {map dimensions}, 
             stride = {stride dimensions}, 
             sharing = {sharing flags},
             autoPadding = {padding flags (boolean)},
             lowerPad = {lower padding (int)},
             upperPad = {upper padding (int)},
             maxTempMemSizeInSamples = 0)

Convolution() calcule la convolution d’une matrice de poids avec une image ou un capteur. Cette opération est utilisée dans les applications de traitement d’images et le traitement du langage. Il prend en charge toutes les dimensions, la progression, le partage ou le remplissage.

Cette fonction fonctionne sur les tenseurs d’entrée du formulaire [M1 x M2 x ... x Mn x inChannels]. Cela peut être compris comme un objet de classementn , où chaque entrée se compose d’un inChannelsvecteur -dimensionnel. Par exemple, une image RVB aurait des dimensions [W x H x 3], c’est-à-dire une [W x H]structure de taille, où chaque entrée (pixel) se compose d’un 3 tuple (remarque, cependant, que le format de stockage de mémoire est la concaténation de 3 plans de taille [W x H]).

Convolution() convole l’entrée avec n+1des filtres -dimensionnels, où les premières n dimensions sont l’étendue spatiale du filtre, et la dernière doit être égale à inChannels. Il existe des outChannels filtres. Par exemple, pour chaque position de sortie, un vecteur de dimension outChannels est calculé. Par conséquent, le nombre total de paramètres de filtre est (M1*M2*...*Mn) * inChannels * outChannels.

Convolution() a les paramètres suivants :

  • w - poids de filtre convolution, stocké sous forme de matrice de dimensions [outChannels, (M1*M2*...*Mn)], où (M1*M2*...*Mn) doit être le produit des dimensions du noyau, par exemple 75 pour un [5 x 5]filtre de taille sur 3 canaux d’entrée.
  • input - entrée convolution. Un capteur avec des dimensions [M1 x M2 x ... x Mn x inChannels].
  • kernel dimensions - dimensions des filtres , y compris le nombre de canaux d’entrée, donnés en tant que vecteur BrainScript. La dernière dimension doit être égale au nombre de canaux d’entrée. Par exemple, (5:5:3) pour un filtre sur une [5 x 5] entrée de 3 canaux.
  • mapDims - [nommé, facultatif, la valeur par défaut est 0] nombre de canaux de sortie (=appelés outChannels ci-dessus; identique à la profondeur du mappage de fonctionnalités résultant). 0 signifie utiliser la dimension de ligne de w
  • stride - [nommé, facultatif, par défaut est de 1] dimensions de progression. Une stride > 1 signifie que seules les positions de pixels qui sont multiples de la valeur de la stride sont calculées. Par exemple, une progression de 2 conduit à un halvage des dimensions. La dernière dimension de progression qui s’aligne sur le nombre de canaux d’entrée doit être égale au nombre de canaux d’entrée.
  • sharing - [nommé, facultatif, par défaut est vrai] indicateurs de partage pour chaque dimension d’entrée
  • autoPadding - [nommé, facultatif, facultatif, est vrai] indicateurs pour chaque dimension d’entrée qu’elle doit être rembourrée automatiquement (autrement dit, symétriquement) ou non rembourrée du tout. Le remplissage signifie que le noyau de convolution est appliqué à toutes les positions de pixels, où tous les pixels en dehors de la zone sont supposés zéro (« rembourrés avec zéros »). Sans remplissage, les noyaux ne sont déplacés que sur les positions où toutes les entrées du noyau restent à l’intérieur de la zone. Dans ce cas, la dimension de sortie est inférieure à la dimension d’entrée. La dernière valeur qui s’aligne avec le nombre de canaux d’entrée doit être false.
  • lowerPad - [nommé, facultatif, par défaut est 0] remplissage inférieur précis pour chaque dimension d’entrée.
  • upperPad - [nommé, facultatif, par défaut est 0] remplissage supérieur précis pour chaque dimension d’entrée.
  • maxTempMemSizeInSamples - [nommé facultatif] quantité maximale de mémoire auxiliaire (dans des exemples) qui doit être réservée pour effectuer des opérations de convolution. Certains moteurs convolution (par exemple, cuDNN et LES moteurs GEMM) peuvent tirer parti de l’utilisation de l’espace de travail, car ils peuvent améliorer les performances. Toutefois, parfois, cela peut entraîner une utilisation plus élevée de la mémoire. La valeur par défaut est 0, ce qui signifie que les exemples d’entrée sont identiques.

Toutes les valeurs du formulaire {...} doivent être données sous forme de séquence de valeurs séparées par deux-points, par exemple (5:5) pour les dimensions du noyau. (Si vous utilisez le déprécié NDLNetworkBuilder, ceux-ci doivent être séparés par des virgules et placés à { } la place.)

Exemple :

ConvReLULayer(inp, outMap, inMap, kW, kH, hStride, vStride, wScale, bValue) =
[
    W = Parameter (outMap, inMap * kW * kH, init="gaussian", initValueScale=wScale)
    b = Parameter (outMap, 1, init="fixedValue", value=bValue)
    c = Convolution (W, inp, (kW:kH:inMap), stride=(hStride:vStride:inMap), autoPadding=(true:true:false))
    y = RectifiedLinear (c + b)
].y

Remarque : Si vous utilisez le déprécié NDLNetworkBuilder, il ne doit pas y avoir de .y fin dans l’exemple.

Convolution 2D simplifiée (NDL déconseillé uniquement)

Le langage NDL désormais déconseillé a fourni une variante 2D simplifiée de Convolution():

Convolution (w, image, 
             kernelWidth, kernelHeight, mapDims, 
             horizontalStride, verticalStride,
             zeroPadding=false, maxTempMemSizeInSamples=0, imageLayout="cudnn" /* or "HWC"*/ )

où :

  • w - matrice de poids convolution, elle a les dimensions de [mapDims, kernelWidth * kernelHeight * inputChannels].
  • image - image d’entrée.
  • kernelWidth - largeur du noyau
  • kernelHeight - hauteur du noyau
  • mapDims - profondeur de la carte des fonctionnalités de sortie (nombre de canaux de sortie)
  • horizontalStride - pas à pas dans une direction horizontale
  • verticalStride - pas à pas dans la direction verticale
  • zeroPadding - [nommé facultatif] spécifie si les côtés de l’image doivent être rembourrés avec des zéros. La valeur par défaut est false.
  • maxTempMemSizeInSamples - [nommé facultatif] quantité maximale de mémoire auxiliaire (dans des exemples) qui doit être réservée pour effectuer des opérations de convolution. Certains moteurs convolution (par exemple, cuDNN et LES moteurs GEMM) peuvent tirer parti de l’utilisation de l’espace de travail, car ils peuvent améliorer les performances. Toutefois, parfois, cela peut entraîner une utilisation plus élevée de la mémoire. La valeur par défaut est 0, ce qui signifie que les exemples d’entrée sont identiques.
  • imageLayout - [nommé facultatif] format de stockage de chaque image. Il s’agit d’une option héritée. Par défaut, elle HWCsignifie que chaque image est stockée comme [channel, width, height] dans la colonne principale. Si vous utilisez cuDNN pour accélérer l’entraînement, vous devez le cudnndéfinir sur , ce qui signifie que chaque image est stockée en tant que [width, height, channel]. Notez que la cudnn disposition fonctionne à la fois sur GPU et sur l’UC. Il est donc recommandé de l’utiliser par défaut.