Wie berechne rezeptive Feld Größe?

Hier ist ein weiterer Weg, um berechnet rezeptive Feld direkt. Stackoverflow unterstützt keine mathematische Formel, für eine besser lesbare version, entnehmen Sie bitte Berechnung Rezeptive Feld von CNN

Des rezeptiven Feldes (RF) $l_k$ layer $k$ ist:

$$ l_k = l_{k-1} + ((f_k - 1) * prod_{i=1}^{k-1}s_i) $$

wo $l_{k-1}$ ist das rezeptive Feld des layer - $k-1$, $f_k$ ist der filter Größe
(Höhe oder Breite, aber vorausgesetzt, Sie sind gleich hier), und $s_i$ ist die Schrittlänge
der layer $i$.

Den oben aufgeführten Formel berechnet rezeptive Feld von unten nach oben (aus der Schicht
1). Intuitiv, RF in der Ebene $k$ deckt $(f_k - 1) * s_{k-1}$ mehr Pixel
relativ mit layer - $k-1$. Jedoch das Inkrement umgesetzt werden muss, um die
erste Schicht, also die Schrittweite ist ein Fakt --- ein Schritt in layer - $k-1$ ist
exponentiell mehr Fortschritte in den unteren Schichten.

Hoffe, das ist hilfreich.

Wie oben, mit möglicherweise korrekte Berechnung von RF:

#Compute input size that leads to a 1x1 output size, among other things   

# [filter size, stride, padding]

convnet =[[11,4,0],[3,2,0],[5,1,2],[3,2,0],[3,1,1],[3,1,1],[3,1,1],[3,2,0],[6,1,0]]
layer_name = ['conv1','pool1','conv2','pool2','conv3','conv4','conv5','pool5','fc6-conv']
imsize = 227

def outFromIn(isz, layernum = 9, net = convnet):
    if layernum>len(net): layernum=len(net)

    totstride = 1
    insize = isz
    #for layerparams in net:
    for layer in range(layernum):
        fsize, stride, pad = net[layer]
        outsize = (insize - fsize + 2*pad) /stride + 1
        insize = outsize
        totstride = totstride * stride
    return outsize, totstride

def inFromOut( layernum = 9, net = convnet):
    if layernum>len(net): layernum=len(net)
    outsize = 1
    #for layerparams in net:
    for layer in reversed(range(layernum)):
        fsize, stride, pad = net[layer]
        outsize = ((outsize -1)* stride) + fsize
    RFsize = outsize
    return RFsize

if __name__ == '__main__':

    print "layer output sizes given image = %dx%d" % (imsize, imsize)
    for i in range(len(convnet)):
        p = outFromIn(imsize,i+1)
        rf = inFromOut(i+1)
        print "Layer Name = %s, Output size = %3d, Stride = % 3d, RF size = %3d" % (layer_name[i], p[0], p[1], rf)

Davon ausgehen, dass wir eine Netzwerk-Architektur, die nur umfassen mehrere convolution-Schichten. Für jede convolution-Schicht, definieren wir ein Quadrat kernel-Größe und eine Dilatation rate. Auch, davon Ausgehen, dass die Schrittlänge ist 1. So können Sie berechnen die rezeptiven Feldes von dem Netzwerk, indem Sie das folgende Stück python-code:

K=[3,3]   # Kernel Size
R=[1,2]  # Dilation Rate

RF=1
d=1 # Depth
for k,r in zip(K,R):
    support=k+(k-1)*(r-1) # r-dilated conv. adds r-1 zeros among coefficients
    RF=support+(RF-1)
    print('depth=%d, K=%d, R=%d, kernel support=%d'%(d,k,r,support))
    d=d+1
print('Receptive Field: %d'%RF)

Als ein Beispiel, lassen Sie uns berechnen, das rezeptive Feld (RF) der bekannten DnCNN (Rauschunterdrückung convolutional neural network) [1].
Verwenden Sie das obige Stück code mit der folgenden Eingänge werden zur Berechnung des RF des Netzwerks. (Sie erhalten RF=35).

# In DnCNN-S, the network has 17 convolution layers.
K=[3]*17  # Kernel Size
R=[1]*17  # Dilation Rate

[1] Zhang, Kai, et al. "Über eine Gauß-denoiser: Passives lernen von deep cnn für Bild-Rauschunterdrückung." IEEE Transactions on Image Processing 26.7 (2017): 3142-3155.