機械学習の精度が上がらない

Question

###前提・実現したいこと
tensorflowを使ったテストプログラムを作成し、機械学習に必要十分なデータ量がどれだけなのか、その感覚を掴みたい、またはそのデータ量を推定するための見当のつけ方を身につけたい。です。

###発生している問題・エラーメッセージ
現在、「4つの値を入力とし、そのうち2番目の値と4番目の値が一致していれば０、不一致なら１を出力する」というルールで入力データ・学習データを自動生成し、学習・評価するプログラムを回しています。
**これの精度が上がらず、なぜ上がらないのかご教授いただきたい。**というのが今回の質問になります。

以下は100個のデータを渡して10000回学習を行い、1000回ごと及び学習終了後にテストデータによる評価をした結果です。誤差の値も上下を繰り返しており、精度も90%にすら届きません。

loss: 0.694365 accuracy: 0.400000
loss: 0.691950 accuracy: 0.600000
loss: 0.700912 accuracy: 0.400000
loss: 0.695201 accuracy: 0.400000
loss: 0.691830 accuracy: 0.600000
loss: 0.703954 accuracy: 0.400000
loss: 0.691710 accuracy: 0.600000
loss: 0.686128 accuracy: 0.600000
loss: 0.694570 accuracy: 0.400000
loss: 0.695068 accuracy: 0.400000

loss: 0.690764
accuracy: 0.600000

###該当のソースコード
ソースコード自体にスクリプトのパスは書かず、コマンドラインからpythonコマンドを叩いています。

import numpy as np
from numpy.random import randint
import tensorflow as tf
from pprint import pprint

# パラメータ設定
BATCH_SIZE = 100        # 1回の学習に用いるデータ数
NUM_TESTS = 25          # テストデータのデータ数
INPUT_DIMENSION = 4     # 入力データの次元数
HIDDEN_DIMENSION = 2    # 隠れ層の次元数
OUTPUT_CLASSES = 2      # 2クラスロジスティック回帰
LEARNING_RATE = 0.2     # 学習率
TRAIN_TIMES = 10000     # 学習回数

# テストデータの生成
# [1]と[3]の値は１か２のみで、この二つを比較し出力とする
def createSuperviserData(nDatas):
    inData = []
    outData = []
    for i in range(nDatas):
        tmpIn = [
            float(randint(18, 81)),
            float(randint(1, 3)),
            float(randint(18, 81)),
            float(randint(1, 3)),
        ]
        if tmpIn[1] == tmpIn[3]:
            tmpOut = [1, 0]
        else:
            tmpOut = [0, 1]
        inData.append(tmpIn)
        outData.append(tmpOut)
    return [inData, outData]

# 推論モデル
def inference(input_placeholder):
    # 隠れ層を一つ設ける
    with tf.name_scope('hidden'):
        W = tf.Variable(tf.zeros([INPUT_DIMENSION, HIDDEN_DIMENSION]), name='weight')
        b = tf.Variable(tf.zeros([HIDDEN_DIMENSION]), name='bias')
        _h = tf.nn.relu(tf.matmul(input_placeholder, W) + b, name='inference')

    W = tf.Variable(tf.zeros([HIDDEN_DIMENSION, OUTPUT_CLASSES]), name='weight')
    b = tf.Variable(tf.zeros([OUTPUT_CLASSES]), name='bias')
    y = tf.add(tf.matmul(_h, W), b, name='inference')

    return y

# 誤差。交差エントロピーを使う
def loss(logits, labels):
    labels = tf.to_int64(labels)
    xentropy = tf.nn.softmax_cross_entropy_with_logits(
            logits=logits, labels=labels)
    xentropy_mean = tf.reduce_mean(xentropy, name='loss')
    return xentropy_mean

# 訓練モデル。勾配降下法
def training(loss):
    optimizer = tf.train.GradientDescentOptimizer(LEARNING_RATE)
    train_step = optimizer.minimize(loss, name='training')
    return train_step

# モデルの精度確認
def accuracy(logits, labels):
    current_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))
    accuracy = tf.reduce_mean(tf.cast(current_prediction, tf.float32), name='accuracy')
    return accuracy

if __name__ == '__main__':
    # プレースホルダーなどを定義
    with tf.name_scope('superviser'):
        inputs = tf.placeholder(tf.float32, shape=(None, INPUT_DIMENSION), name='x')
        labels = tf.placeholder(tf.float32, shape=(None, OUTPUT_CLASSES), name='y')
        test_input, test_output = createSuperviserData(NUM_TESTS)
        test_feed_dict = {inputs: test_input, labels: test_output}
    pprint({'test_input': test_input, 'test_output': test_output})

    # 演算用のモデルなどを定義
    with tf.name_scope('main_op'):
        logits = inference(inputs)
        loss = loss(logits, labels)
        train_op = training(loss)
        accuracy = accuracy(logits, labels)
    pprint({'inputs':inputs,'labels':labels,'logits':logits,'loss':loss,
            'train_op':train_op,'accuracy':accuracy})
    print()

    # 訓練開始
    with tf.Session() as sess:
        init = tf.global_variables_initializer()
        init.run()
        for i in range(TRAIN_TIMES):
            x, y = createSuperviserData(BATCH_SIZE)
            sess.run(train_op, feed_dict={inputs:x, labels:y})
            if i % (TRAIN_TIMES//10) == 0:
                curLoss = sess.run(loss, feed_dict=test_feed_dict)
                curAccuracy = sess.run(accuracy, feed_dict=test_feed_dict)
                print('loss: %.6f accuracy: %.6f' % (curLoss, curAccuracy))
        print()
        print('loss: %.6f' % sess.run(loss, feed_dict=test_feed_dict))
        print('accuracy: %.6f' % sess.run(accuracy, feed_dict=test_feed_dict))

###試したこと
LEARNING_RATEとTRAIN_TIMESを中心に、パラメータを色々いじりながら試行を繰り返していますが、何が問題なのか見えていない状態です。

###補足情報(言語/FW/ツール等のバージョンなど)
Windows 10 にてVagrantでCentOS7の環境を用意し、そこでtensorflowのテストプログラムを作成しています。

[vagrant@localhost python]$ cat /etc/redhat-release
CentOS Linux release 7.3.1611 (Core)
[vagrant@localhost python]$ pyenv versions
system

• anaconda3-4.0.0 (set by /home/vagrant/.pyenv/version)

[vagrant@localhost python]$ python -V
Python 3.5.3 :: Anaconda custom (64-bit)

Answer 1

欠損関数が一向に下がらないのは、2クラス分類でソフトマックス関数を使っている為だと思われます。
2クラスではシグモイド関数を使うのが主流と聞いたので、
変更した所、欠損関数に限っては簡単に下げる事が出来ました。

import numpy as np
from numpy.random import randint
import tensorflow as tf
from pprint import pprint

# パラメータ設定
BATCH_SIZE = 100        # 1回の学習に用いるデータ数
NUM_TESTS = 25          # テストデータのデータ数
INPUT_DIMENSION = 4     # 入力データの次元数
HIDDEN_DIMENSION = 2    # 隠れ層の次元数
OUTPUT_CLASSES = 2      # 2クラスロジスティック回帰
LEARNING_RATE = 0.2     # 学習率
TRAIN_TIMES = 10000     # 学習回数

# テストデータの生成
# [1]と[3]の値は１か２のみで、この二つを比較し出力とする
def createSuperviserData(nDatas):
    inData = []
    outData = []
    for i in range(nDatas):
        tmpIn = [
            float(randint(18, 81)),
            float(randint(1, 3)),
            float(randint(18, 81)),
            float(randint(1, 3)),
        ]
        if tmpIn[1] == tmpIn[3]:
            tmpOut = [1, 0]
        else:
            tmpOut = [0, 1]
        inData.append(tmpIn)
        outData.append(tmpOut)
    return [inData, outData]

# 推論モデル
def inference(input_placeholder):
    # 隠れ層を一つ設ける
    with tf.name_scope('hidden'):
        W = tf.Variable(tf.truncated_normal([INPUT_DIMENSION, HIDDEN_DIMENSION],
                                             stddev=tf.sqrt(2.0 / INPUT_DIMENSION),
                                             name='weight'))
        b = tf.Variable(tf.truncated_normal([HIDDEN_DIMENSION],
                                             stddev=0.1,
                                             name='bias'))

        _h = tf.nn.relu(tf.matmul(input_placeholder, W) + b, name='inference')


    W = tf.Variable(tf.truncated_normal([HIDDEN_DIMENSION, OUTPUT_CLASSES],
                                         stddev=tf.sqrt(2.0 / HIDDEN_DIMENSION),
                                         name='weight'))

    b = tf.Variable(tf.truncated_normal([OUTPUT_CLASSES],
                                            stddev=0.1,
                                            name='bias'))
    y = tf.add(tf.matmul(_h, W), b, name='inference')
    y = tf.nn.sigmoid(y)

    return y

# 誤差。交差エントロピーを使う
def loss(logits, labels):
    xentropy = -tf.reduce_sum(labels * tf.log(tf.clip_by_value(logits, 1e-10, 1.0),
                                                                          ),axis=1)
    xentropy_mean = tf.reduce_mean(xentropy, name='loss')
    return xentropy_mean

# 訓練モデル。勾配降下法
def training(loss):
    optimizer = tf.train.GradientDescentOptimizer(LEARNING_RATE)
    train_step = optimizer.minimize(loss, name='training')
    return train_step

# モデルの精度確認
def accuracy(logits, labels):
    current_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))
    accuracy = tf.reduce_mean(tf.cast(current_prediction, tf.float32), name='accuracy')
    return accuracy

if __name__ == '__main__':
    # プレースホルダーなどを定義
    with tf.name_scope('superviser'):
        inputs = tf.placeholder(tf.float32, shape=(None, INPUT_DIMENSION), name='x')
        labels = tf.placeholder(tf.float32, shape=(None, OUTPUT_CLASSES), name='y')
        test_input, test_output = createSuperviserData(NUM_TESTS)
        test_feed_dict = {inputs: test_input, labels: test_output}
    pprint({'test_input': test_input, 'test_output': test_output})

    # 演算用のモデルなどを定義
    with tf.name_scope('main_op'):
        logits = inference(inputs)
        loss = loss(logits, labels)
        train_op = training(loss)
        accuracy = accuracy(logits, labels)
    pprint({'inputs':inputs,'labels':labels,'logits':logits,'loss':loss,
            'train_op':train_op,'accuracy':accuracy})
    print()

    # 訓練開始
    with tf.Session() as sess:
        init = tf.global_variables_initializer()
        init.run()
        for i in range(TRAIN_TIMES):
            x, y = createSuperviserData(BATCH_SIZE)
            sess.run(train_op, feed_dict={inputs:x, labels:y})
            if i % (TRAIN_TIMES//10) == 0:
                curLoss = sess.run(loss, feed_dict=test_feed_dict)
                curAccuracy = sess.run(accuracy, feed_dict=test_feed_dict)
                print('loss: %.6f accuracy: %.6f' % (curLoss, curAccuracy))
                print()
        print('loss: %.6f' % sess.run(loss, feed_dict=test_feed_dict))
        print('accuracy: %.6f' % sess.run(accuracy, feed_dict=test_feed_dict))

loss: 0.628812 accuracy: 0.440000

loss: 0.010268 accuracy: 0.440000

loss: 0.005082 accuracy: 0.560000

loss: 0.003374 accuracy: 0.560000

loss: 0.002525 accuracy: 0.440000

loss: 0.002017 accuracy: 0.560000

loss: 0.001679 accuracy: 0.440000

loss: 0.001438 accuracy: 0.440000

loss: 0.001257 accuracy: 0.440000

loss: 0.001117 accuracy: 0.440000

loss: 0.001005
accuracy: 0.440000

追記
ちょっとした実験をしてみました

import tensorflow as tf
import numpy as np
from dataset.mnist import load_mnist

訓練データ = []
正解ラベル = []

"""任意の比率で訓練データを作成する。
   引数で100の内、正解ラベル[1,0]の訓練データを何個作るかを決める"""

def 訓練_正解データ(value):
    訓練データ = []
    正解ラベル = []
    for i in range(value):
        x = np.random.randint(1, 3) * 0.01
        入力値 = [
        np.random.randint(18, 81) * 0.01,
        x,
        np.random.randint(18, 81) * 0.01,
        x,
        ]

        正解値 = [1, 0]

        訓練データ.append(入力値)
        正解ラベル.append(正解値)
        #ここから残りの2割の訓練データを埋める
        if  i == value - 1:
            while len(訓練データ) < 100:
                x = np.random.randint(1, 3) * 0.01
                y = np.random.randint(1, 3) * 0.01

                if x == y:
                    continue

                入力値 = [
                np.random.randint(18, 81) * 0.01,
                x,
                np.random.randint(18, 81) * 0.01,
                y,
                ]

                正解値 = [0, 1]
                訓練データ.append(入力値)
                正解ラベル.append(正解値)

                """念の為シャッフルする"""
                シード値 = np.random.randint(0,1000)

                np.random.seed(シード値)
                np.random.shuffle(訓練データ)

                np.random.seed(シード値)
                np.random.shuffle(正解ラベル)

    return [訓練データ, 正解ラベル]

print(訓練_正解データ(100))

"""パラメーターの作成をする"""
入力数 = 4
中間数 = 100
出力数 = 2

入力ホルダ = tf.placeholder(tf.float32, [None, 入力数])
正解ホルダ = tf.placeholder(tf.float32, [None, 出力数])
キープ率 = tf.placeholder(tf.float32)

重み1 = tf.Variable(tf.truncated_normal([入力数, 中間数],
                                        stddev=tf.sqrt(2.0 /入力数)))
バイアス1 = tf.Variable(tf.truncated_normal([中間数],
                                             stddev=0.1))

重み2 = tf.Variable(tf.truncated_normal([中間数, 出力数],
                                         stddev=tf.sqrt(2.0 / 中間数)))
バイアス2 = tf.Variable(tf.truncated_normal([出力数],
                                             stddev=0.1))

"""伝達処理をする"""
一層目 = tf.matmul(入力ホルダ, 重み1) + バイアス1
活性化1 = tf.nn.relu(一層目)
ドロップアウト1 = tf.nn.dropout(活性化1, キープ率)
二層目 = tf.matmul(ドロップアウト1, 重み2) + バイアス2
出力層 = tf.nn.sigmoid(二層目)

"""欠損関数を作成する。
   欠損値がnanにならないようにtf.clip_by_valueで対策する"""
欠損値バッチ = -tf.reduce_sum(正解ホルダ * tf.log(tf.clip_by_value(
                                                  出力層, 1e-10, 1.0),
                                                  ),axis=1)
交差エントロピー = tf.reduce_mean(欠損値バッチ)

"""正解率の作成"""
真理値判定 = tf.equal(tf.argmax(出力層, 1), tf.argmax(正解ホルダ, 1))
正解率 = tf.reduce_mean(tf.cast(真理値判定, tf.float32))

"""確率的勾配下降の作成"""
勾配下降 = tf.train.GradientDescentOptimizer(0.01).minimize(交差エントロピー)

with tf.Session() as セッション:
    セッション.run(tf.global_variables_initializer())

    for i in range(10000):
        #学習させる比率を決める
        n, m = 訓練_正解データ(30)
        セッション.run(勾配下降, feed_dict={
                       入力ホルダ:n,正解ホルダ:m,キープ率:1.0})

        if i % 100 == 0:
            #テストデータの比率を決める
            testn, testm = 訓練_正解データ(90)
            out, sigmoid = セッション.run([二層目, 出力層], feed_dict={
                                     入力ホルダ:n,正解ホルダ:m,
                                     キープ率:1.0})

            print(out)
            print(sigmoid)
            テスト = セッション.run(正解率, feed_dict={
                                    入力ホルダ:testn,正解ホルダ:testm,
                                    キープ率:1.0})

            print(テスト)

前回のコードとの変更点は第一に、入力する値を小さくしています(0.01倍)
シグモイド関数に値を通しても、数値大小が変わる事はありません
しかし一定の数値を超えると、数値の大小に限らず1を返すようです。
当然そうなれば正常な判断が出来ません
試しに0.01倍を外してみるとわかると思います
画像を学習させる時も、普通は、その配列の中で最も大きい値で割る、平均の値で全ての配列を割るなどして値を小さくしますので、今回もそれに乗っ取ります

過学習対策のドロップアウト層も組み込んでいます。
一言で言えば、訓練データをニューラルネットに丸暗記をさせてはいけないのですが、一定確率でランダムなユニットを除去する事で、1ループだけ学習を停滞させ、丸暗記を防いでいます
ただし今回の場合は、特に効果は見られなかったので、キープ率は1.0のそのままにしてあります

そして実験用に、正解ラベルが[1,0]か[0,1]かを任意の比率で生成できる関数を作ってみました
自分の推測では、[1,0]が正解ラベルの時は出力層の一層目の値が大きくなるように変動し、
[0,1]が正解ラベルの時は出力層の二層目の値が大きくなるように変動するというものでした
比率を決める事で、本当にそうなるのかを確かめてみます

ではまず、上に張り付けたコードを実行してみてください。
このコードでは訓練データを3:7([1,0] ,[0,1])の比率で与えてみます
コードで言うとn, m = 訓練_正解データ(30)

テストデータは9:1の割合で与えます
testn, testm = 訓練_正解データ(90)

今回の場合ですと、自分の推測通りであれば、訓練データに[0,1]のデータを多く与えているわけですから二層目の値が大きくなるように学習をします
その結果テストデータで与える[1,0]が正解ラベルのデータに関しては全て不正解になるはずです
つまり9:1の割合でテストデータを与えると正解率は1割と推測できます

実際に実行してみると正解率が0.1になるのがわかると思います。

その他与える比率を変えてみてください
比率が傾いた方に出力層が大きくなり、そうでない方のテストデータは全て不正解になるはずです
また訓練、テストともに5:5で与えると多少のばらつきはあるものの50%に収束していきます

この実装が間違っていない限りは、真理値判定でも出来ない限りは、これに対応できる関数を作るのは難しく
、収束していった結果がこの正解率なのが伺えると思います

Comments

[gittib_gittib]

回答ありがとうございます。大変参考になりました。
あれから色々試しているのですが、隠れ層を調整する事で対応できないかな、と考えています。
その層で、「2番目と4番目が同じ値である」とか「違う値である」という特徴を拾ってくれれば、このケースでも対応できるのではないでしょうか。
隠れ層はそのような特徴を見つけ出してくれるもの、というイメージを持っていたのですが、そんな簡単な話ではないですかね・・・

[退会済みユーザー]

このような形のネットワークを全結合層と言ったりしますが、この層の役割はそれに適応できる関数を作る、という方が正しいような気がします。例えば、与えられた入力値に対して、倍の数値を出力として出したいならパラメーター全体で×2になるような関数を作れば問題解決できるわけです
手書き数字などの人間がわからないような数字の配列も、何かしらの関数を作り分類してくれるわけです。
そういう意味では特徴を捉えて関数を作ってくれると言えるかもしれませんが本質ではない気がします
また、隠れ層の役割は関数の柔軟性(表現力)を高める役割を担っているという認識です

一般的に、特徴を抽出する役目を担う部分は、畳み込み層と呼ばれる部分です。手書き数字であれば、画像全体を入力値として無作為に与えるのではなく、特徴を抽出した部分の値だけを与える事で、全結合層で関数が作りやすくなり、結果として認識精度があがるといった感じです

今回の問題の場合、全結合層だけで何とかしようと思ったら真理値判定に近いような関数でも作ってくれない限り、精度をあげるのは難しいように見えます...あくまでもイメージなので絶対にできないという自信があるわけではありませんが

[gittib_gittib]

ありがとうございます。隠れ層は「関数の柔軟性を高める」という事を読ませていただき、ようやく理解できたように思います。
確かに、このケースでは2,4番目の値を座標と見立てて出力をプロットした場合、直線では区切れない。よって直線ではない区切り方が必要なので、その点において隠れ層が効果を発揮する、という事ですね。

まあ今改めると、質問に挙げたサンプルプログラムの隠れ層が適切に設計されているとは、思えないですが。
ともあれ、機械学習について大いに理解を進められましたので、上記回答をベストアンサーにさせていただきます。
ありがとうございました。

[退会済みユーザー]

既に理解されたみたいなので必要はないと思いますが、少し実験してみました。
まあすれ違いですね><