TIM Labs

プーリングのサイズをコマンドラインから指定可能にした

| コメント(0) | トラックバック(0)
プーリングのサイズを2や3で解説している例が多い。
たぶん、サイズを大きくしてしまうと、目が荒くなりすぎて、情報が漏れてしまう気がする。
でも、サイズが大きくなると、どのようにダメになっていくのもきちんと確認すべきではないだろうか。
ということで、コマンドラインからプーリングのサイズを指定できるようにした。

つまり、コマンド行で、 -p でプーリングサイズを指定できるようにしようという訳。
CIFAR-10$ python train_cifar5.py -g 0 -u 500 500 -p 4
GPU: 0
# number: 50000
# units: [500, 500]
# pooling: 4
# Minibatch-size: 100
# epoch: 20

プログラムは、最後にまとめて示す。
CNNオブジェクト(model)を生成するときに、プーリングサイズを渡すようにした。
渡されたプーリングのサイズはCNNオブジェクトの変数に記憶させておき、実際にプーリング処理をするときにサイズを参照するようにした。

プーリングサイズを大きくしていくな何が起きるのか、予想をしよう。
 サイズは、2か3あたりが良い。 それとも、もっと大きくして、7,8,9あたりの方が実は良いとか。
さすがに画像サイズと同程度になってしまったら、ダメだろうな。

実験の報告は、次回からになる。

以下が、プログラム全体である。
#!/usr/bin/env python

from __future__ import print_function

try:
    import matplotlib
    matplotlib.use('Agg')
except ImportError:
    pass

import argparse

import chainer
import chainer.functions as F
import chainer.links as L
from chainer import training
from chainer.training import extensions


# Network definition
class CNN(chainer.Chain):

    def __init__(self, n_units, n_out, p_size):
        super(CNN, self).__init__(
            conv1=L.Convolution2D(None, 36, 3),     # 畳み込み
            conv2=L.Convolution2D(None, 36, 4),     # 畳み込み
            l1=L.Linear(None, n_units[0]),  #            -> n_units[0]
            l2=L.Linear(None, n_units[1]),  # n_units[0] -> n_units[1]
            l3=L.Linear(None, n_out),  	    # n_units[1] -> n_out
        )
        self.pooling_size = p_size
        
    def __call__(self, x):
        c1 = F.relu(self.conv1(x))                  # 畳み込み
        c2 = F.relu(self.conv2(c1))                 # 畳み込み
        p1 = F.max_pooling_2d(c2,self.pooling_size)      # プーリング
        h1 = F.relu(self.l1(p1))
        h2 = F.relu(self.l2(h1))
        return self.l3(h2)


def main():
    parser = argparse.ArgumentParser(description='Chainer example: MNIST')
    parser.add_argument('--batchsize', '-b', type=int, default=100,
                        help='Number of images in each mini-batch')
    parser.add_argument('--epoch', '-e', type=int, default=20,
                        help='Number of sweeps over the dataset to train')
    parser.add_argument('--frequency', '-f', type=int, default=-1,
                        help='Frequency of taking a snapshot')
    parser.add_argument('--gpu', '-g', type=int, default=-1,
                        help='GPU ID (negative value indicates CPU)')
    parser.add_argument('--out', '-o', default='result',
                        help='Directory to output the result')
    parser.add_argument('--resume', '-r', default='',
                        help='Resume the training from snapshot')
    parser.add_argument('--units', '-u', type=int, nargs='+', default=[1000,1000],
                        help='Number of units')
    parser.add_argument('--number', '-n', type=int, default=50000,
                        help='Number of training data')
    parser.add_argument('--pooling', '-p', type=int, default=2,
                        help='Size of pooling matrix')
    args = parser.parse_args()

    print('GPU: {}'.format(args.gpu))
    print('# number: {}'.format(args.number))
    print('# units: {}'.format(args.units))
    print('# pooling: {}'.format(args.pooling))
    print('# Minibatch-size: {}'.format(args.batchsize))
    print('# epoch: {}'.format(args.epoch))
    print('')

    # Set up a neural network to train
    # Classifier reports softmax cross entropy loss and accuracy at every
    # iteration, which will be used by the PrintReport extension below.
    model = L.Classifier(CNN(args.units, 10, args.pooling))
    if args.gpu >= 0:
        chainer.cuda.get_device(args.gpu).use()  # Make a specified GPU current
        model.to_gpu()  # Copy the model to the GPU

    # Setup an optimizer
    optimizer = chainer.optimizers.Adam()
    optimizer.setup(model)

    # Load the MNIST dataset
    train, test = chainer.datasets.get_cifar10()
    train = train[:args.number]

    train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
    test_iter = chainer.iterators.SerialIterator(test, args.batchsize,
                                                 repeat=False, shuffle=False)

    # Set up a trainer
    updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
    trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)

    # Evaluate the model with the test dataset for each epoch
    trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))

    # Dump a computational graph from 'loss' variable at the first iteration
    # The "main" refers to the target link of the "main" optimizer.
    trainer.extend(extensions.dump_graph('main/loss'))

    # Take a snapshot for each specified epoch
    frequency = args.epoch if args.frequency == -1 else max(1, args.frequency)
    trainer.extend(extensions.snapshot(), trigger=(frequency, 'epoch'))

    # Write a log of evaluation statistics for each epoch
    trainer.extend(extensions.LogReport())

    # Save two plot images to the result dir
    if extensions.PlotReport.available():
        trainer.extend(
            extensions.PlotReport(['main/loss', 'validation/main/loss'],
                                  'epoch', file_name='loss.png'))
        trainer.extend(
            extensions.PlotReport(
                ['main/accuracy', 'validation/main/accuracy'],
                'epoch', file_name='accuracy.png'))

    # Print selected entries of the log to stdout
    # Here "main" refers to the target link of the "main" optimizer again, and
    # "validation" refers to the default name of the Evaluator extension.
    # Entries other than 'epoch' are reported by the Classifier link, called by
    # either the updater or the evaluator.
    trainer.extend(extensions.PrintReport(
        ['epoch', 'main/loss', 'validation/main/loss',
         'main/accuracy', 'validation/main/accuracy', 'elapsed_time']))

    # Print a progress bar to stdout
    trainer.extend(extensions.ProgressBar())

    if args.resume:
        # Resume from a snapshot
        chainer.serializers.load_npz(args.resume, trainer)

    # Run the training
    trainer.run()


if __name__ == '__main__':
    main()

トラックバック(0)

トラックバックURL: http://labs.timedia.co.jp/mt/mt-tb.cgi/629

コメントする

このブログ記事について

このページは、fujiが2017年5月28日 00:00に書いたブログ記事です。

ひとつ前のブログ記事は「データ解析のための統計モデリング入門 一般化線形混合モデル(GLMM) 読書メモ4」です。

次のブログ記事は「データ解析のための統計モデリング入門 一般化線形混合モデル(GLMM) 読書メモ5」です。

最近のコンテンツはインデックスページで見られます。過去に書かれたものはアーカイブのページで見られます。