python pkg の Convolutional Neural Network のコード (Chainer)

Question

python の pkg にある fcn のコードについて分からないことがあり質問させていただきました。pip install fcn でインストールできる以下のコードに
h = upscore[:, :, 19:19+x.data.shape[2], 19:19+x.data.shape[3]]
とあります。
これは Deconvolution した特徴マップを入力画像サイズにあうように crop していると思うのですが、なぜ 19 から配列を取り出しているのかわかりません。お分かりの方がいらっしゃいましたらご教授いただけないでしょうか。
入力画像のサイズは 300~500 pix のものが入ります。
よろしくお願いします。

import math

import chainer
import chainer.functions as F
import chainer.links as L
import numpy as np

import fcn

class FCN32s(chainer.Chain):

    """Full Convolutional Network 32s"""

    def __init__(self, n_class=21):
        self.n_class = n_class
        super(self.__class__, self).__init__(
            conv1_1=L.Convolution2D(3, 64, 3, stride=1, pad=100),
            conv1_2=L.Convolution2D(64, 64, 3, stride=1, pad=1),

            conv2_1=L.Convolution2D(64, 128, 3, stride=1, pad=1),
            conv2_2=L.Convolution2D(128, 128, 3, stride=1, pad=1),

            conv3_1=L.Convolution2D(128, 256, 3, stride=1, pad=1),
            conv3_2=L.Convolution2D(256, 256, 3, stride=1, pad=1),
            conv3_3=L.Convolution2D(256, 256, 3, stride=1, pad=1),

            conv4_1=L.Convolution2D(256, 512, 3, stride=1, pad=1),
            conv4_2=L.Convolution2D(512, 512, 3, stride=1, pad=1),
            conv4_3=L.Convolution2D(512, 512, 3, stride=1, pad=1),

            conv5_1=L.Convolution2D(512, 512, 3, stride=1, pad=1),
            conv5_2=L.Convolution2D(512, 512, 3, stride=1, pad=1),
            conv5_3=L.Convolution2D(512, 512, 3, stride=1, pad=1),

            fc6=L.Convolution2D(512, 4096, 7, stride=1, pad=0),
            fc7=L.Convolution2D(4096, 4096, 1, stride=1, pad=0),

            score_fr=L.Convolution2D(4096, self.n_class, 1, stride=1, pad=0),

            upscore=L.Deconvolution2D(self.n_class, self.n_class, 64,
                                      stride=32, pad=0),
        )
        self.train = False

    def __call__(self, x, t=None):
        self.x = x
        self.t = t

        # conv1
        h = F.relu(self.conv1_1(x))
        conv1_1 = h
        h = F.relu(self.conv1_2(conv1_1))
        conv1_2 = h
        h = F.max_pooling_2d(conv1_2, 2, stride=2, pad=0)
        pool1 = h  # 1/2

        # conv2
        h = F.relu(self.conv2_1(pool1))
        conv2_1 = h
        h = F.relu(self.conv2_2(conv2_1))
        conv2_2 = h
        h = F.max_pooling_2d(conv2_2, 2, stride=2, pad=0)
        pool2 = h  # 1/4

        # conv3
        h = F.relu(self.conv3_1(pool2))
        conv3_1 = h
        h = F.relu(self.conv3_2(conv3_1))
        conv3_2 = h
        h = F.relu(self.conv3_3(conv3_2))
        conv3_3 = h
        h = F.max_pooling_2d(conv3_3, 2, stride=2, pad=0)
        pool3 = h  # 1/8

        # conv4
        h = F.relu(self.conv4_1(pool3))
        h = F.relu(self.conv4_2(h))
        h = F.relu(self.conv4_3(h))
        h = F.max_pooling_2d(h, 2, stride=2, pad=0)
        pool4 = h  # 1/16

        # conv5
        h = F.relu(self.conv5_1(pool4))
        h = F.relu(self.conv5_2(h))
        h = F.relu(self.conv5_3(h))
        h = F.max_pooling_2d(h, 2, stride=2, pad=0)
        pool5 = h  # 1/32

        # fc6
        h = F.relu(self.fc6(pool5))
        h = F.dropout(h, ratio=.5, train=self.train)
        fc6 = h  # 1/32

        # fc7
        h = F.relu(self.fc7(fc6))
        h = F.dropout(h, ratio=.5, train=self.train)
        fc7 = h  # 1/32

        # score_fr
        h = self.score_fr(fc7)
        score_fr = h  # 1/32

        # upscore
        h = self.upscore(score_fr)
        upscore = h  # 1

        # score
        h = upscore[:, :, 19:19+x.data.shape[2], 19:19+x.data.shape[3]]
        self.score = h  # 1/1

        if t is None:
            assert not self.train
            return

        # testing with t or training
        self.loss = F.softmax_cross_entropy(self.score, t, normalize=False)
        if math.isnan(self.loss.data):
            raise ValueError('loss value is nan')

        # report the loss and accuracy
        batch_size = len(x.data)
        labels = chainer.cuda.to_cpu(t.data)
        label_preds = chainer.cuda.to_cpu(self.score.data).argmax(axis=1)
        results = []
        for i in xrange(batch_size):
            acc, acc_cls, iu, fwavacc = fcn.util.label_accuracy_score(
                labels[i], label_preds[i], self.n_class)
            results.append((acc, acc_cls, iu, fwavacc))
        results = np.array(results).mean(axis=0)
        chainer.reporter.report({
            'loss': self.loss,
            'accuracy': results[0],
            'acc_cls': results[1],
            'iu': results[2],
            'fwavacc': results[3],
        }, self)

        return self.loss

Answer 1

README.mdを読むと

This is Chainer implementation of fcn.berkeleyvision.org.

とありますから、元のFCN実装と同じことをしているのでしょう。そちらを見てみると、たとえばVOCのFCN-32sのコードでは

     n.score = crop(n.upscore, n.data)

とだけ書かれていて、刈り込みの詳細はcaffe.coord_map.crop()にあるようです。そちらの仕様を調べれば、なぜ19というマジックナンバが出てくるのかわかるでしょう (ご自分で調べてみて下さい)。