Chainerの学習がうまくいかない

Question

前提

chainerで画像分類の実験を行っています。学習させたモデルでテストを行うと0.1％しか出ないという状態です。
画像のデータセットについては特に問題ないと考えています。

実現したいこと

• 問題の解決

該当のソースコード

テスト用のコード

#!/usr/bin/env python
"""Example code of learning a large scale convnet from ILSVRC2012 dataset.

Prerequisite: To run this example, crop the center of ILSVRC2012 training and
validation images and scale them to 256x256, and make two lists of space-
separated CSV whose first column is full path to image and second column is
zero-origin label (this format is same as that used by Caffe's ImageDataLayer).

"""
from __future__ import print_function
import argparse
import datetime
import json
import multiprocessing
import random
import sys
import threading
import time

import numpy as np
from PIL import Image


import six
import six.moves.cPickle as pickle
import _pickle as cPickle  #変更
from six.moves import queue

import chainer
import matplotlib.pyplot as plt
import numpy as np
import math
import chainer.functions as F
import chainer.links as L
from chainer.links import caffe
from matplotlib.ticker import * 
from chainer import serializers

from functools import cmp_to_key  #追加



parser = argparse.ArgumentParser(
    description='Image inspection using chainer')
parser.add_argument('image', help='Path to inspection image file')
parser.add_argument('--model','-m',default='model', help='Path to model file')
parser.add_argument('--mean', default='mean.npy',
                    help='Path to the mean file (computed by compute_mean.py)')
parser.add_argument('--out', '-o')
args = parser.parse_args()


def read_image(path, center=False, flip=False):
  image = np.asarray(Image.open(path)).transpose(2, 0, 1)
  if center:
    top = left = cropwidth // 2
  else:
    top = random.randint(0, cropwidth - 1)
    left = random.randint(0, cropwidth - 1)
  bottom = model.insize + top
  right = model.insize + left
  image = image[:, top:bottom, left:right].astype(np.float32)
  image -= mean_image[:, top:bottom, left:right]
  image /= 255
  if flip and random.randint(0, 1) == 0:
    return image[:, :, ::-1]
  else:
    return image

import nin

mean_image = cPickle.load(open(args.mean, 'rb'))

model = cPickle.load(open(args.model,'rb'))

#mean_image = cPickle.load(open(args.mean, 'rb'))
#model = cPickle.load(open(args.model,'rb',))

#serializers.load_hdf5("gpu1out.h5", model)
cropwidth = 256 - model.insize
model.to_cpu()


def predict(net, x):
    h = F.max_pooling_2d(F.relu(net.mlpconv1(x)), 3, stride=2)
    h = F.max_pooling_2d(F.relu(net.mlpconv2(h)), 3, stride=2)
    h = F.max_pooling_2d(F.relu(net.mlpconv3(h)), 3, stride=2)
    #h = net.mlpconv4(F.dropout(h, train=net.train))
    h = net.mlpconv4(F.dropout(h))
    h = F.reshape(F.average_pooling_2d(h, 6), (x.data.shape[0], 1000))
    return F.softmax(h)

#setattr(model, 'predict', predict)

img = read_image(args.image)
x = np.ndarray(
        (1, 3, model.insize, model.insize), dtype=np.float32)
x[0]=img
#x = chainer.Variable(np.asarray(x), volatile='on')
x= chainer.Variable(np.asarray(x))
with chainer.no_backprop_mode():

     score = predict(model,x)
#score=cuda.to_cpu(score.data)

categories = np.loadtxt("labels.txt", str, delimiter="\t")

top_k = 20
#↓list()を追加
prediction = list(zip(score.data[0].tolist(), categories))
#prediction.sort(cmp=lambda x, y: cmp(x[0], y[0]), reverse=True)
prediction.sort (key=lambda x: x[0],reverse=True)

for rank, (score, name) in enumerate(prediction[:top_k], start=1):
     print('#%d | %s | %4.1f%%' % (rank, name, score * 100))


今回使用した　nin.py
import math
import chainer
import chainer.functions as F
import chainer.links as L


class NIN(chainer.Chain):

    """Network-in-Network example model."""

    insize = 227

    def __init__(self):
        w = math.sqrt(2)  # MSRA scaling
        super(NIN, self).__init__(
            mlpconv1=L.MLPConvolution2D(
                3, (96, 96, 96), 11, stride=4),
            mlpconv2=L.MLPConvolution2D(
                96, (256, 256, 256), 5, pad=2), #wscale=w削除
            mlpconv3=L.MLPConvolution2D(
                256, (384, 384, 384), 3, pad=1),
            mlpconv4=L.MLPConvolution2D(
                384, (1024, 1024, 1000), 3, pad=2),
        )
        self.train = True

    def clear(self):
        self.loss = None
        self.accuracy = None

    def __call__(self, x, t):
        self.clear()
        h = F.max_pooling_2d(F.relu(self.mlpconv1(x)), 3, stride=2)
        h = F.max_pooling_2d(F.relu(self.mlpconv2(h)), 3, stride=2)
        h = F.max_pooling_2d(F.relu(self.mlpconv3(h)), 3, stride=2)
        h = self.mlpconv4(F.dropout(h)) #変更
        h = F.reshape(F.average_pooling_2d(h, 6), (x.data.shape[0], 1000))

        self.loss = F.softmax_cross_entropy(h, t)
        self.accuracy = F.accuracy(h, t)
        return self.loss
    
    def predict(self, x_data, train=False):
        x = chainer.Variable(x_data, volatile=True)

        h = F.relu(self.conv1(x))
        h = F.relu(self.conv1a(h))
        h = F.relu(self.conv1b(h))
        h = F.max_pooling_2d(h, 3, stride=2)
        h = F.relu(self.conv2(h))
        h = F.relu(self.conv2a(h))
        h = F.relu(self.conv2b(h))
        h = F.max_pooling_2d(h, 3, stride=2)
        h = F.relu(self.conv3(h))
        h = F.relu(self.conv3a(h))
        h = F.relu(self.conv3b(h))
        h = F.max_pooling_2d(h, 3, stride=2)
        h = F.dropout(h, train=train)
        h = F.relu(self.conv4(h))
        h = F.relu(self.conv4a(h))
        h = F.relu(self.conv4b(h))
        h = F.reshape(F.average_pooling_2d(h, 6), (x_data.shape[0], 1000))
        return F.softmax(h)

学習用のコード
def train_loop():
    # Trainer
    graph_generated = False
    while True:
        while data_q.empty():
            time.sleep(0.1)
        inp = data_q.get()
        if inp == 'end':  # quit
            res_q.put('end')
            break
        elif inp == 'train':  # restart training
            res_q.put('train')
            model.train = True
            continue
        elif inp == 'val':  # start validation
            res_q.put('val')
            #serializers.save_npz(args.out, model)
            #model.to_cpu()
            pickle.dump(model, open(args.out, 'wb'), -1)
            serializers.save_npz(args.outstate, optimizer)
            model.train = False
            continue

        volatile = 'off'if model.train else 'on'
        #x = chainer.Variable(xp.asarray(inp[0]), volatile=volatile)
        x = chainer.Variable(xp.asarray(inp[0]))
        with chainer.no_backprop_mode():
        #t = chainer.Variable(xp.asarray(inp[1]),volatile=volatile)
            t = chainer.Variable(xp.asarray(inp[1]))
        with chainer.no_backprop_mode():
　　　　#if model train:
            if model:  
                optimizer.update(model, x, t)
                if not graph_generated:
                    with open('graph.dot', 'w') as o:
                        o.write(computational_graph.build_computational_graph(
                        (model.loss,)).dump())
                    print('generated graph', file=sys.stderr)
                    graph_generated = True
            else:
                model(x, t)
            res_q.put((float(model.loss.data), float(model.accuracy.data)))
            del x, t

data_qにデータを入れる

　def feed_data():
    # Data feeder
    i = 0
    count = 0

    x_batch = np.ndarray(
        (args.batchsize, 3, model.insize, model.insize), dtype=np.float32)
    y_batch = np.ndarray((args.batchsize,), dtype=np.int32)
    val_x_batch = np.ndarray(
        (args.val_batchsize, 3, model.insize, model.insize), dtype=np.float32)
    val_y_batch = np.ndarray((args.val_batchsize,), dtype=np.int32)

    batch_pool = [None] * args.batchsize
    val_batch_pool = [None] * args.val_batchsize
    pool = multiprocessing.Pool(args.loaderjob)
    data_q.put('train')
    for epoch in six.moves.range(1, 1 + args.epoch):
        print('epoch', epoch, file=sys.stderr)
        print('learning rate', optimizer.lr, file=sys.stderr)
        perm = np.random.permutation(len(train_list))
        for idx in perm:
            path, label = train_list[idx]
            batch_pool[i] = pool.apply_async(read_image, (path, False, True))
            y_batch[i] = label
            i += 1

            if i == args.batchsize:
                for j, x in enumerate(batch_pool):
                    x_batch[j] = x.get()
                data_q.put((x_batch.copy(), y_batch.copy()))
                i = 0

            count += 1
            if count % denominator == 0:
                data_q.put('val')
                j = 0
                for path, label in val_list:
                    val_batch_pool[j] = pool.apply_async(
                        read_image, (path, True, False))
                    val_y_batch[j] = label
                    j += 1

                    if j == args.val_batchsize:
                        for k, x in enumerate(val_batch_pool):
                            val_x_batch[k] = x.get()
                        data_q.put((val_x_batch.copy(), val_y_batch.copy()))
                        j = 0
                data_q.put('train')

        optimizer.lr *= 0.97
    pool.close()
    pool.join()
    data_q.put('end')
### 試したこと
学習させる画像の枚数や学習回数を変更した。

Comments

[ps_aux_grep]

画像サイズとConfusion Matrixを示していただけると原因究明に役立ちそうです

[shinww]

画像サイズは256×256です。
confusion matrixを追加していませんが他の関数を使っているということでしょうか。
勉強不足で申し訳ないです。

[ps_aux_grep]

Confusion Matrixとは，分類問題において精度や再現率などを評価するための表です．日本語では混同行列とも呼ばれます．
https://www.google.com/search?q=confusion+matrix

今回使われたデータセットILSVRC2012では1000カテゴリあるとのことで，かつモデルの精度が0.1%なんですよね，この0.1%というのは，ある入力画像に対して1000カテゴリからランダムに何か1つ選ぶときの精度と同じです．つまるところ，このモデルは何も学習していない可能性があります．

ただ，精度だけでは評価しづらいものがあるので，Confusion Matrixによる評価を経て，モデルが完全にRandom Choiceを行うものになっていることを証明した上で，コードやモデルに問題が無いか探そう．というものです．

ちなみにモデルもnet.mlpconv1() -> ReLU() -> MaxPooling2d()の繰り返しであることはわかるのですが，これら畳み込み層のカーネル数などのハイパーパラメータがモデルの性能に影響するので，明示していただきたいところです．

[shinww]

色々とご説明ありがとうございます。今回学習のために使用したコードを↑に追加しました。
学習させるためのコードです。↓
よろしくお願いします。

[ps_aux_grep]

この欄では文頭の半角スペースが消されるので，こちらのコードも質問を編集して書き込んでいただけるとありがたいです．

[ps_aux_grep]

optimizer.update(model, x, t)
の直下に
print(f"acc: {model.accuracy.data}, loss: {model.loss.data}")
として表示させみてください．各epochでの数値の遷移を見てみたいです．微塵も動かなければ学習時のコードがおかしいです．
多分，with chainer.no_backprop_mode():の中でoptimizer.update()しているのがダメだと思います．

[shinww]

実行してみたところ、lossの数値に変化はあったのですが、accの方が0.0のままでした。
train_roopのコードを変える必要があるということでしょうか。

[ps_aux_grep]

> 実行してみたところ、lossの数値に変化はあったのですが、accの方が0.0のままでした。
dropoutがあるので，そのレイヤでの重みの組み合わせで，当然lossの数値に変化が出ます．
私が見たい遷移は，中長期的にどのような増減をしたか，というものになります．
横ばいである場合，学習が進んでいませんし，少しずつ減少するなら少なくとも学習は進んでいる証拠になります．

> train_roopのコードを変える必要があるということでしょうか。
多分そうです，学習時のコードの全体像がまだわからなくて，具体的にどこに原因があるかわからないといった状態です．並列処理でdata_qにクエリを投げている．という理解でよろしいですか？どのようにクエリを投げていますか？

[shinww]

＞私が見たい遷移は，中長期的にどのような増減をしたか，というものになります．
lossのはずっと6.9辺りを動いている感じです。

＞どのようにクエリを投げていますか？
data_qに関するコードを一応↑に追加しました。train_listからnp.random.permutation()を用いてデータをシャッフルして渡しています。

[shinww]

上の場合はできませんでした。
また、volatileが削除されてしまったためwith chainer.no_backprop_mode()を追加したのですが、そういった場合どうすればよいでしょうか。

[ps_aux_grep]

速度に差があるだけなので，とりあえずvolatileなしにするだけで実行してみましょうか
with chainer.no_backprop_mode()を追加されていますが，このなかでVariableを実行すると必ずvolatile=Trueにしたことと同じようになってしまうので，chainer.using_config()で代用してvolatile=Falseの場合の処理も書かなくてはなりません．

[jbpb0]

https://docs.chainer.org/en/latest/upgrade_v2.html#volatile-flag-is-removed
の「Volatile flag is removed」の「Example」を見ると、Chainer v1用のコードで「volatile=True」だった場合は、Chainer v2では「with chainer.no_backprop_mode():」を使うように書いてあります

この質問のコードでは、

> volatile = 'off'if model.train else 'on'

から、「model.trainではない」場合が「volatile=on」(=True)になるので、ps_aux_grepさんの回答のように、「model.trainではない」場合のみ「with chainer.no_backprop_mode():」を使います

[shinww]

お二方多くの解決方法を提示してくださってありがとうございました。

Answer 1

やはり，optimizer.update()がwith chainer.no_backprop_mode():の中にあるのは望ましくないと思われます．

if model.train: 
    x = chainer.Variable(np.asarray(inp[0]))
    t = chainer.Variable(np.asarray(inp[1]))
    optimizer.update(model, x, t)
    if not graph_generated:
        with open('graph.dot', 'w') as o:
            o.write(computational_graph.build_computational_graph(
            (model.loss,)).dump())
        print('generated graph', file=sys.stderr)
        graph_generated = True
else:
    with chainer.no_backprop_mode():
        x = chainer.Variable(np.asarray(inp[0]))
        t = chainer.Variable(np.asarray(inp[1]))
    model(x, t)
res_q.put((float(model.loss.data), float(model.accuracy.data)))
del x, t

Comments

[jbpb0]

https://qiita.com/mitmul/items/1e35fba085eb07a92560
の「5.1 ValidationやTestを行う際の注意点」に書かれてるようなことをして、

model(x, t)

の際に「F.dropout(h)」が無効になるようにしなくても大丈夫でしょうか？

[jbpb0]

同様な理由で、

x= chainer.Variable(np.asarray(x))
with chainer.no_backprop_mode():
score = predict(model,x)

を、下記のように変更しなくても大丈夫でしょうか？

with chainer.using_config('train', False), chainer.using_config('enable_backprop', False):
x= chainer.Variable(np.asarray(x))
score = predict(model,x)

[ps_aux_grep]

コメント補足ありがとうございます
今回は学習出来ない件なので学習時以外のパラメータ設定は無視して進めてましたが，たしかにそこらへんも気を配る必要がありますね

まだ原因があるとすれば，lossのbackwardを明記してないとことか，でしょうか

[jbpb0]

> lossのbackwardを明記してない

それは要らないのではないですかね
https://qiita.com/icoxfog417/items/96ecaff323434c8d677b
の「学習」に、
「中核となるのは更新を行っているoptimizer.updateです。1.5からはlossfunを引数に渡すことで自動的に渡されたlossfunによる誤差計算、伝播(backward)を行ってくれるようになりました。もちろん、今まで通りmodel.zerograds()で勾配を初期化してから自前で誤差の計算・伝播を行い(loss.backward)、optimizer.updateを呼ぶことも可能です。」
と書かれてます

[jbpb0]

> 学習出来ない件

が解決して、

> 学習させたモデルでテストを行うと0.1％しか出ない

がだいぶマシになっても、「F.dropout(h)」の「ratio」のデフォルト値は「0.5」
https://docs.chainer.org/en/stable/reference/generated/chainer.functions.dropout.html
と結構大きいため、テスト時にも有効なままだとテスト結果が思ったほど良くならない、となるかも、と思いまして

[ps_aux_grep]

> 「F.dropout(h)」の「ratio」のデフォルト値は「0.5」
https://docs.chainer.org/en/stable/reference/generated/chainer.functions.dropout.html
と結構大きいため、テスト時にも有効なままだとテスト結果が思ったほど良くならない、となるかも、と思いまして
そうですね，テスト時にも有効だとテストの結果は良くならなさそうです．ですが，学習データに対してフィッティングされていれば学習時の損失は下がるはずですが，上のコメントで申し出ていたように停滞していたとのことなので不活性化率に関しては一旦忘れていました．

[shinww]

↑のコードの修正したところ学習がうまくいくようになりました。ありがとうございました。

[ps_aux_grep]

おめでとうございます．もしまた精度の議論があるときは，Confusion Matrixと学習曲線の提示をお願いします．コードの誤りもここから推測できます