Faltning

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() beräknar sammanslagningen av en viktmatris med en bild eller tensor. Den här åtgärden används i bildbearbetningsprogram och språkbearbetning. Den stöder alla dimensioner, steg, delning eller utfyllnad.

Den här funktionen fungerar på indata tensorer i formuläret [M1 x M2 x ... x Mn x inChannels]. Detta kan förstås som ett rang-n objekt, där varje post består av en inChannels-dimensionell vektor. Till exempel skulle en RGB-bild ha dimensioner [W x H x 3], d.v.s. en [W x H]-storleksstruktur, där varje post (pixel) består av en 3-tuppel (observera dock att minneslagringsformatet är sammanlänkningen av 3 plan med storlek [W x H]).

Convolution()ansluter indata med -dimensionella filter, där de första n dimensionerna är filtrets rumsliga omfattning, och den sista måste vara lika inChannelsmed n+1. Det finns outChannels filter. Dvs. för varje utdataposition beräknas en dimensionsvektor outChannels . Därför är (M1*M2*...*Mn) * inChannels * outChannelsdet totala antalet filterparametrar .

Convolution() har följande parametrar:

• w - Vikter för faltningsfilter, lagrade som en matris med dimensioner [outChannels, (M1*M2*...*Mn)], där (M1*M2*...*Mn) måste vara produkten av kerneldimensionerna, t.ex. 75 för ett [5 x 5]-storleksfilter på 3 indatakanaler.
• input – indata för decentralisering. En tensor med dimensioner [M1 x M2 x ... x Mn x inChannels].
• kernel dimensions - filterdimensioner inklusive antalet indatakanaler som anges som en BrainScript-vektor. Den sista dimensionen måste vara lika med antalet indatakanaler. T.ex. (5:5:3) för ett [5 x 5] filter på en 3-kanalsinmatning.
• mapDims - [namngiven, valfri, standard är 0] antal utdatakanaler (=anropas outChannels ovan; samma som djupet i den resulterande funktionskartan). 0 innebär att raddimensionen w
• stride - [namngivet, valfritt, standard är 1] stegdimensioner. Ett steg > 1 innebär att endast pixelpositioner som är multiplar av stegvärdet beräknas. Till exempel leder ett steg på 2 till en halvering av dimensionerna. Den sista stegdimensionen som överensstämmer med antalet indatakanaler måste vara lika med antalet indatakanaler.
• sharing - [namngivet, valfritt, standard är sant] delningsflaggor för varje indatadimension
• autoPadding - [namngivna, valfria, standard är sant] flaggor för varje indatadimension, oavsett om den ska fyllas ut automatiskt (det vill sig symmetriskt) eller inte vadderas alls. Utfyllnad innebär att faltningskärnan tillämpas på alla pixelpositioner, där alla pixlar utanför området antas vara noll ("vadderade med nollor"). Utan utfyllnad flyttas kernels bara över positioner där alla indata till kerneln fortfarande hamnar i området. I det här fallet är utdatadimensionen mindre än indatadimensionen. Det sista värdet som radas upp med antalet indatakanaler måste vara false.
• lowerPad - [namngiven, valfri, standard är 0] exakt lägre utfyllnad för varje indatadimension.
• upperPad - [namngiven, valfri, standard är 0] exakt övre utfyllnad för varje indatadimension.
• maxTempMemSizeInSamples - [namngivet valfritt] maximal mängd extra minne (i exempel) som ska reserveras för att utföra konvolutionsåtgärder. Vissa faltningsmotorer (t.ex. cuDNN- och GEMM-baserade motorer) kan dra nytta av att använda arbetsytan eftersom det kan förbättra prestandan. Ibland kan detta dock leda till högre minnesanvändning. Standardvärdet är 0, vilket innebär samma sak som indataexemplen.

Alla värden i formuläret {...} måste faktiskt anges som en kolonavgränsad sekvens med värden, t.ex. (5:5) för kerneldimensionerna. (Om du använder den inaktuella NDLNetworkBuildermåste dessa vara kommaavgränsade och omslutna i { } stället.)

Exempel:

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

Obs! Om du använder det inaktuella NDLNetworkBuilderbör det inte finnas något avslutande .y i exemplet.

Förenklad 2D-decentralisering (endast inaktuell NDL)

Det nu inaktuella NDL-språket gav en förenklad 2D-variant av Convolution():

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

där:

• w – viktmatris för faltning, den har dimensionerna [mapDims, kernelWidth * kernelHeight * inputChannels].
• image – indatabilden.
• kernelWidth – kärnans bredd
• kernelHeight – kernelns höjd
• mapDims – Djup på funktionskartan för utdata (antal utdatakanaler)
• horizontalStride - stega i vågrät riktning
• verticalStride - stega i lodrät riktning
• zeroPadding - [namngiven valfritt] anger om sidorna av bilden ska fyllas med nollor. Standardvärdet är false.
• maxTempMemSizeInSamples - [namngivet valfritt] maximal mängd extra minne (i exempel) som ska reserveras för att utföra konvolutionsåtgärder. Vissa faltningsmotorer (t.ex. cuDNN- och GEMM-baserade motorer) kan dra nytta av att använda arbetsytan eftersom det kan förbättra prestandan. Ibland kan detta dock leda till högre minnesanvändning. Standardvärdet är 0, vilket innebär samma sak som indataexemplen.
• imageLayout - [namngiven valfritt] lagringsformatet för varje bild. Det här är ett äldre alternativ. Som standard är HWCdet , vilket innebär att varje bild lagras som [channel, width, height] i kolumnmajor. Om du använder cuDNN för att påskynda träningen bör du ställa in den på cudnn, vilket innebär att varje bild lagras som [width, height, channel]. Observera att cudnn layouten fungerar både på GPU och CPU, så vi rekommenderar att du använder den som standard.