CNN・セグメンテーションの重み更新量を1回ごとに表示したい

Question

前提・実現したいこと

現在、chainerを使ってセグメンテーションを行っています。
chainerのTrainerという機能に、バッチサイズや学習モデル、エポック数などを渡すと自動で学習して答えを出してくれます。
今回は、学習の一回一回で計算して更新される重み量を可視化して表示したいと思っています。
セグメンテーションにおける重みとはカーネル（フィルタ）の値だと思うので、それを白黒の画像（扱っているのがグレースケール画像なので）として表示したいと思っています。

Trainerの中身

def create_trainer(batchsize, train, val, stop, device=-1, log_trigger=(1, 'epoch')):
    model = FullyConvolutionalNetwork(out_h=200, out_w=200)
    train_model = PixelwiseSigmoidClassifier(model)#ここで目的関数を決めているようだ

    # 最適化手法にSGDを使用(勾配降下法のひとつ)
    optimizer = optimizers.SGD()
    optimizer.setup(train_model)

    # データセットから，指定したバッチサイズ数のデータ点をまとめて取り出して返すイテレータを定義
    train_iter = iterators.MultiprocessIterator(train, batchsize)
    val_iter = iterators.MultiprocessIterator(val, batchsize, repeat=False, shuffle=False)

    # イテレータからデータを引き出し，モデルに渡して，目的関数の値を計算し，backwardしてパラメータを更新，
    # までの一連の処理を行う updater を定義
    updater = training.StandardUpdater(train_iter, optimizer, device=device)

    # 様々な付加機能をExtensionとして与えられるTrainerを使用
    trainer = training.trainer.Trainer(updater, stop, out='result_fcn')

    logging_attributes = [
        'epoch', 'main/loss', 'main/miou', 'main/pa',
        'val/main/loss', 'val/main/miou', 'val/main/pa']
    trainer.extend(extensions.LogReport(logging_attributes), trigger=log_trigger)
    trainer.extend(extensions.PrintReport(logging_attributes), trigger=log_trigger)
    trainer.extend(extensions.PlotReport(['main/loss', 'val/main/loss'], 'epoch', file_name='loss.png'))
    trainer.extend(extensions.PlotReport(['main/miou', 'val/main/miou'], 'epoch', file_name='miou.png'))
    trainer.extend(extensions.PlotReport(['main/pa', 'val/main/pa'], 'epoch', file_name='pa.png'))
    trainer.extend(extensions.Evaluator(val_iter, train_model, device=device), name='val')
    trainer.extend(extensions.dump_graph('main/loss'))
    return trainer

試したこと

更新はoptimizerやStandardUpdaterの中で行われているため、重みがreturnとしてmain関数に返ってくることはありません。
上記のコード中のoptimizerの中身（今回はSGD）とStandardUpdaterの中身を読んでいるのですが、どのパラメータが重みなのか分かりません。計算のコード上での動きも知りたいです。ご教授お願いいたします。

一応、SGD・optimizerのクラスのコードを張っておきます。

from chainer.backends import cuda
from chainer.backends import intel64
from chainer import optimizer


_default_hyperparam = optimizer.Hyperparameter()
_default_hyperparam.lr = 0.01 #学習係数の設定値


class SGDRule(optimizer.UpdateRule):

    _kernel = None

    def __init__(self, parent_hyperparam=None, lr=None):
        super(SGDRule, self).__init__(#サブクラス自身SGDRuleのスーパークラスを探す（答えはoptimizer.UpdateRule）．つまりスーパークラスの初期化メソッドを継承するという宣言
            parent_hyperparam or _default_hyperparam)
        if lr is not None:
            self.hyperparam.lr = lr

    def update_core_cpu(self, param):
        grad = param.grad #誤差関数の偏微分はこれ。param.gradはスーパークラスoptimizer.UpdateRule内で定義されている。
        if grad is None:
            return
        if isinstance(param.data, intel64.mdarray):
            param.data.inplace_axpby(1.0, -self.hyperparam.lr, grad)
        else:
            param.data -= self.hyperparam.lr * grad

    def update_core_gpu(self, param):
        grad = param.grad
        if grad is None:
            return
        if SGDRule._kernel is None:
            SGDRule._kernel = cuda.elementwise(
                'T grad, T lr', 'T param',
                'param -= lr * grad', 'sgd')
        SGDRule._kernel(grad, self.hyperparam.lr, param.data)


class SGD(optimizer.GradientMethod):

    def __init__(self, lr=_default_hyperparam.lr):
        super(SGD, self).__init__()
        self.hyperparam.lr = lr

    lr = optimizer.HyperparameterProxy('lr')

    def create_update_rule(self):
        return SGDRule(self.hyperparam)

（↓一部です）

class UpdateRule(object):#sgd.pyのサブクラスSGDRuleでスーパークラスとして参照されてる。

    def __init__(self, parent_hyperparam=None):
        self._pre_update_hooks = collections.OrderedDict()
        self._post_update_hooks = collections.OrderedDict()
        self._state = None
        self.enabled = True
        self.hyperparam = Hyperparameter(parent_hyperparam)
        self.t = 0
        self._use_fp32_update = False #TrueかFalseのboolタイプ
        self._fp32_param = None

    @property
    def state(self):
        """State dictionary."""
        return self._state

    def add_hook(self, hook, name=None, timing='auto'):

        if not callable(hook):
            raise TypeError('hook function must be callable')
        if timing not in ('pre', 'post', 'auto'):
            raise ValueError("timing must be one of ('pre', 'post', 'auto')")
        if timing == 'auto':
            timing = getattr(hook, 'timing', 'pre')

        if name is None:
            name = getattr(hook, 'name', getattr(hook, '__name__', None))
            if name is None:
                raise ValueError(
                    'the name of the hook function is not specified')
        if name in self._pre_update_hooks or name in self._post_update_hooks:
            raise ValueError('hook "{}" already exists'.format(name))

        if timing == 'pre':
            self._pre_update_hooks[name] = hook
        else:
            self._post_update_hooks[name] = hook

    def remove_hook(self, name):

        try:
            del self._pre_update_hooks[name]
        except KeyError:
            del self._post_update_hooks[name]

    def update(self, param):

        if not self.enabled:
            return

        self.t += 1

        if self._use_fp32_update and param.dtype == numpy.float16:
            if self._fp32_param is None:
                self._fp32_param = variable.Variable(
                    param.array.astype(numpy.float32),
                    name=param.name)
            fp32_param = self._fp32_param
            fp32_param.grad = param.grad.astype(numpy.float32)

            if fp32_param.data is not None:
                self._prepare(fp32_param)
            if param._loss_scale is not None:
                fp32_param.grad /= param._loss_scale
            for hook in six.itervalues(self._pre_update_hooks):
                hook(self, fp32_param)
            self.update_core(fp32_param)
            for hook in six.itervalues(self._post_update_hooks):
                hook(self, fp32_param)

            param.data = fp32_param.data.astype(param.dtype)
            fp32_param.grad = None
        else:
            if param.data is not None:
                self._prepare(param)
            if param._loss_scale is not None:
                param.grad /= param._loss_scale
            for hook in six.itervalues(self._pre_update_hooks):
                hook(self, param)
            self.update_core(param)
            for hook in six.itervalues(self._post_update_hooks):
                hook(self, param)

    def update_core(self, param):

        with cuda.get_device_from_array(param.data) as dev:
            if int(dev) == -1:
                self.update_core_cpu(param)
            else:
                self.update_core_gpu(param)

    def update_core_cpu(self, param):

        raise NotImplementedError

    def update_core_gpu(self, param):

        raise NotImplementedError

    def init_state(self, param):

        pass

    def serialize(self, serializer):

        self.t = serializer('t', self.t)
        if self.state is None:
            if isinstance(serializer, serializer_module.Deserializer):
                # try to initialize the state to retrieve state entries
                self._state = {}
                self_copy = copy.copy(self)
                arr = numpy.empty(1, dtype=numpy.float32)
                self_copy.init_state(variable.Variable(arr, grad=arr))

                for key in self._state:
                    try:
                        value = serializer(key, None)
                    except KeyError:
                        if self.enabled:
                            raise
                        value = None
                    # leave the update rule state as `None` if the keys are not
                    # contained in the snapshot, so that these states can be
                    # automatically initialized with the `_prepare` method
                    if value is None:
                        self._state = None
                        break
                    else:
                        self._state[key] = value
        else:
            for key in self._state:
                self._state[key] = serializer(key, self._state[key])

    def _prepare(self, param):
        with cuda.get_device_from_array(param.data) as device:
            state = self.state
            if state is None:
                state = self._state = {}
                self.init_state(param)

            for name, value in six.iteritems(state):
                if not isinstance(value, (numpy.ndarray, cuda.ndarray)):
                    continue
                value_device = cuda.get_device_from_array(value)
                if value_device.id != device.id:
                    if device.id >= 0:
                        state[name] = cuda.to_gpu(value)
                    else:
                        state[name] = cuda.to_cpu(value)

    def use_fp32_update(self, flag=True):
       
        self._use_fp32_update = flag

Comments

[Q71]

iPhone からで調べられないからこっちで。
Chain から導出して、ネットワークを構成しているクラスに定義している Convolution_2d の W のはず。
Python のデバッグ環境があるなら、__call__ などで止めて、内容を確認してみましょう。

[deb]

Convolution_2d内のforward関数の中にプリント文を入れたら重みWを表示できました！
optimizerやStandrdUpdaterは型であって具体的な値はConvolution_2dに出てくるのですね。
ご回答ありがとうございました。

Answer 1

chainer/links/connection/convolution_2d.py の クラスConvolution2D の forward関数内にある、self.Wが重みパラメータ。このままではVariable型なのでself.W.dataとして配列にすれば、plt.omshow(im)で表示可能。