ニューラルネットワーク 学習が上手くいかない

Question

自分でニューラルネットワークを作っています。手始めに、論理回路を学習させてみようと思い、入力層2ノード、隠れ層30ノード、出力層1ノードの三層のニューラルネットワークを構築しました。重みの初期値は-1.0から1.0までの値を偏りなくランダムに設定します。学習効率は0.03で、学習は、(1,1)(0,1)(1,0)(0,0)の入力と答えを順番に学習させ、これを1000回繰り返します。
この時、ANDやORは正しく?学習できましたが、XORやEXORの学習は上手くいきませんでした。
左の値は入力値で右の値は出力値です。いくつか結果を挙げます。

(1,1) = 0.750126
(1,0) = 0.188411
(0,1) = 0.187444
(0,0) = 0.00650456

(1,1) = 0.982309
(1,0) = 0.887062
(0,1) = 0.891423
(0,0) = 0.173294

(1,1) = 0.511378
(1,0) = 0.510599
(0,1) = 0.500787
(0,0) = 0.48574

(1,1) = 0.514631
(1,0) = 0.500916
(0,1) = 0.497562
(0,0) = 0.493797

//一番目の値=出力値
(1,1) = 0.903502 
(1,0) = 0.926415 
(0,1) = 0.0982237 
(0,0) = 0.0923838 

グラフ上で線形に答えが区切れる場合だけ正しく学習出来ているように思えます。何が問題だと考えられますか？

参考のため、以下に全コードを張り付けておきます。

//main.cpp
#include <array>
#include "neural.h"
int main() {
	NeuralNetwork<2, 30, 1> logic(0.03);
	array<double, 1> result;
	for (size_t i = 0; i < 1000; i++)
	{
		logic.study({ {1,1} }, { {1} });
		logic.study({ {1,0} }, { {1} });
		logic.study({ {0,1} }, { {0} });
		logic.study({ {0,0} }, { {0} });
	}
	result = logic.calculate({ {1,1} });
	std::cout << "(1,1) = " << result[0] << endl;
	result = logic.calculate({ {1,0} });
	std::cout << "(1,0) = " << result[0] << endl;
	result = logic.calculate({ {0,1} });
	std::cout << "(0,1) = " << result[0] << endl;
	result = logic.calculate({ {0,0} });
	std::cout << "(0,0) = " << result[0] << endl;
}

//neural.h
#include <random>
#include <cmath>
#include <sstream>
#include <array>
#include <functional>

template <typename _Ty, size_t _column, size_t _row> class matrix {
private:
	std::array<std::array<_Ty, _row>, _column> content;
public:
	static void foreach(std::function<void(size_t colmun, size_t row)> doeach, std::function<void(size_t colmun)>doeachendofcolumn = [](size_t colmun) {}) {
		for (size_t i = 0; i < _column; i++)
		{
			for (size_t j = 0; j < _row; j++)
			{
				doeach(i, j);
			}
			doeachendofcolumn(i);
		}
	}
	matrix() { foreach([&](size_t i, size_t j) {content[i][j] = _Ty(); }); };
	matrix(std::array<std::array<_Ty, _row>, _column> i) { content = i; }
	constexpr size_t row() const { return _row; }
	constexpr size_t column() const { return _column; }
	matrix<_Ty, _row, _column> transpose() const { matrix<_Ty, _row, _column>re; foreach([&](size_t i, size_t j) {re[j][i] = content[i][j]; }); return re; }
	std::array<_Ty, _row> const& operator [](size_t t) const { return content[t]; }
	std::array<_Ty, _row>& operator [](size_t t) { return content[t]; }
	matrix<_Ty, _column, _row>& operator +=(matrix<_Ty, _column, _row> const& m) {
		foreach([&](size_t i, size_t j) {content[i][j] = content[i][j] + m[i][j]; });
		return *this;
	}
	matrix<_Ty, _column, _row>& operator -=(matrix<_Ty, _column, _row> const& m) {
		foreach([&](size_t i, size_t j) {content[i][j] = content[i][j] - m[i][j]; });
		return *this;
	}
	matrix<_Ty, _column, _row>& operator *=(size_t i) {
		foreach([&](size_t i, size_t j) {content[i][j] *= i; });
		return *this;
	}
	template<typename _nTy>
	operator _nTy() const { matrix<_nTy, _column, _row> re; foreach([&](size_t i, size_t j) {re[i][j] = (_nTy)content[i][j]; }); return re; }
	std::string str() const {
		std::stringstream ss;
		foreach([&](size_t i, size_t j) {ss << content[i][j] << ",\t"; }, [&](size_t) { ss << "\n"; });
		return ss.str();
	}
};
template <typename _Ty, size_t _column, size_t _row>
const matrix<_Ty, _column, _row> operator +(matrix<_Ty, _column, _row> const& f, matrix<_Ty, _column, _row> const& s) {
	return matrix<_Ty, _column, _row>(f) += s;
}
template <typename _Ty, size_t _column, size_t _row>
const matrix<_Ty, _column, _row> operator -(matrix<_Ty, _column, _row> const& f, matrix<_Ty, _column, _row> const& s) {
	return matrix<_Ty, _column, _row>(f) -= s;
}
template <typename _Ty, size_t _column, size_t _row_scolumn, size_t _srow>
const matrix<_Ty, _column, _srow> operator *(matrix<_Ty, _column, _row_scolumn> const& f, matrix<_Ty, _row_scolumn, _srow> const& s) {
	matrix<_Ty, _column, _srow> re;
	matrix<_Ty, _column, _row_scolumn>::foreach([&](size_t i, size_t j) {
		for (size_t k = 0; k < _srow; k++) {
			re[i][k] += f[i][j] * s[j][k];//配列を横に動いてから縦に動くのでメモリアクセス的に高速なはず
		}
		});

	return re;
}
template <typename _Ty, size_t _column, size_t _row>
const matrix<_Ty, _column, _row> operator *(size_t i, matrix<_Ty, _column, _row> const& m) {
	return matrix<_Ty, _column, _row>(m) *= i;
}
template <typename _Ty, size_t _column, size_t _row>
const matrix<_Ty, _column, _row> operator *(matrix<_Ty, _column, _row> const& m, size_t i) {
	return m * i;
}

std::random_device seed_gen;
std::default_random_engine engine(seed_gen());
constexpr double sigmoid_range = 34.538776394910684;
double sigmoid(double d) {
	if (d > sigmoid_range) d = sigmoid_range;
	if (d < -sigmoid_range) d = -sigmoid_range;
	return 1 / (1 + std::exp(-d));
}
void avoid_flow(double& d, double upper_range = 1.0e300, double under_range = 1.0e-300) {
	if (d < -upper_range) d = -upper_range;
	if (d > -under_range && d < under_range) d = 0;
	if (d > upper_range) d = upper_range;
}
template<size_t nodecount>
class Layer {
private:
	matrix<double, nodecount, 1> nodes;
public:
	Layer() {};
	Layer(matrix<double, nodecount, 1> m) { nodes = m; }
	operator matrix<double, nodecount, 1>() { return nodes; }
	Layer(std::array<double, nodecount> ar) {
		for (size_t i = 0; i < nodecount; i++)
		{
			nodes[i][0] = ar[i];
		}
	}
	operator std::array<double, nodecount>() {
		std::array<double, nodecount> re;
		for (size_t i = 0; i < nodecount; i++) {
			re[i] = nodes[i][0];
		}
		return re;
	}
	double& operator[](size_t i) { return nodes[i][0]; }
	void activation() {
		for (size_t i = 0; i < nodecount; i++)
		{
			nodes[i][0] = sigmoid(nodes[i][0]);
		}
	}
};
template<size_t inputnodecount, size_t outputnodecount>
class Weight {
private:
	matrix<double, outputnodecount, inputnodecount> weight;
public:
	Weight() {};
	Weight(matrix<double, outputnodecount, inputnodecount> const& m) { weight = m; };
	void renew(Layer<inputnodecount> input, Layer<outputnodecount> delta, double learning_rate) {
		weight.foreach([&](size_t i, size_t j) {weight[i][j] -= learning_rate * delta[i] * input[j];  avoid_flow(weight[i][j]); });
	}
	Weight<outputnodecount, inputnodecount> transpose() { return weight.transpose(); };
	operator matrix<double, outputnodecount, inputnodecount>() { return weight; }
	std::array<double, inputnodecount> operator[](size_t i) { return weight[i]; }
	void randamize() {
		std::uniform_real_distribution<> rnd(-1.0, 1.0);
		weight.foreach([&](size_t i, size_t j) {weight[i][j] = rnd(engine); });
	}
};
template<size_t inputnodecount, size_t outputnodecount>
Layer<outputnodecount> const operator*(Weight<inputnodecount, outputnodecount> weight, Layer<inputnodecount> layer) { return (matrix<double, outputnodecount, inputnodecount>)weight * (matrix<double, inputnodecount, 1>)layer; }
template<size_t inputnodecount, size_t hiddennodecount, size_t outputnodecount>
class NeuralNetwork {
private:
	double learning_rate;
	Weight<inputnodecount, hiddennodecount> input_to_hidden;
	Weight<hiddennodecount, outputnodecount> hidden_to_output;
	std::tuple<Layer<inputnodecount>, Layer<hiddennodecount>, Layer<outputnodecount>>  calc(Layer<inputnodecount> input) {
		Layer<hiddennodecount> hidden = input_to_hidden * input;
		hidden.activation();
		Layer<outputnodecount> output = hidden_to_output * hidden;
		output.activation();
		std::tuple<Layer<inputnodecount>, Layer<hiddennodecount>, Layer<outputnodecount>> re = std::make_tuple(input, hidden, output);
		return re;
	}
public:
	explicit NeuralNetwork(double rate = 0.3) :learning_rate(rate) { input_to_hidden.randamize(); hidden_to_output.randamize(); };
	std::array<double, outputnodecount> calculate(std::array<double, inputnodecount> in) {
		return std::get<2>(calc(in));
	}
	void study(std::array<double, inputnodecount> in, std::array<double, outputnodecount> answer) {
		Layer<inputnodecount> input;
		Layer<hiddennodecount> hidden;
		Layer<outputnodecount> output;
		std::tie(input, hidden, output) = calc(in);
		Layer<outputnodecount> delta_out;
		for (size_t i = 0; i < outputnodecount; i++)
		{
			delta_out[i] = (output[i] - answer[i]) * output[i] * (1.0 - output[i]);
		}
		hidden_to_output.renew(hidden, delta_out, learning_rate);
		Layer<hiddennodecount> delta_hidden = hidden_to_output.transpose() * delta_out;
		input_to_hidden.renew(input, delta_hidden, learning_rate);
	}
};

Answer 1

質問者様のコードを直接読み解いたわけではありませんが、tensorflowで同じモデルを組んでみたところ、optimizerによってはxorは学習しきれない、という事象が出ました。基本的なSGDだとダメで、Adamにするとうまくいきます。これをヒントに、見直してみるとよいでしょう。

発生している事象から考えると、活性化層がうまく機能しておらず非線形が表現できていないのかと思いました。ところが、コードを少し読み解くと、sigmoidが入っているようでした。よって、別要因だと思い、tensorflowで試してみたわけです。

追記: optimizerはSGDのままでも、入力層の活性化をsigmoidからreluに変えてみたところ、学習ができました。こちらの方が「普通」の実装ですし、かつ試しやすいものと思います。sigmoidを重ねることによる勾配消失が、SGDと相性が悪いのかな、と思います。

なお、フレームワークに頼らずご自分で機械学習をゼロから作られるツワモノな方が時々いらっしゃいます。しかし、その動作で疑問が出た際には、ご自分のコードを確かめる前に、まずはフレームワークで同じことをやってみてどうか、を確認するとよいと思います。

試したコードは以下

from tensorflow.keras import Sequential, optimizers
from tensorflow.keras.layers import Dense

# データ作成
x, y, = [], []
for _ in range(1000):
    x.append([1, 1])
    x.append([0, 1])
    x.append([1, 0])
    x.append([0, 0])
    # y.extend([1, 0, 0, 0])   # and
    # y.extend([1, 1, 1, 0])   # or
    y.extend([0, 1, 1, 0])   # xor

# モデル作成
model = Sequential([
    Dense(30, input_dim=2, activation='sigmoid'),
    Dense(1, activation='sigmoid')
])
optimizer = optimizers.SGD(lr=0.03)
# optimizer = optimizers.Adam(lr=0.03)
model.compile(optimizer=optimizer, loss='mse', metrics='mse')

# 学習と推論
result = model.fit(x, y, batch_size=1, epochs=1)
y_pred = model.predict([[1, 1], [0, 1], [1, 0], [0, 0]])
print(y_pred)

実行結果

# and、optimizer.SGD (学習を増やすともっと精度が高まる)
[[0.6408773 ]
 [0.20385471]
 [0.21725073]
 [0.03093234]]
# or、optimizer.SGD (学習を増やすともっと精度が高まる)
[[0.9758366]
 [0.831491 ]
 [0.8254561]
 [0.2677223]]
# xor、optimizer.SGD (学習を増やしても精度が高まらない)
[[0.5727341 ]
 [0.56092936]
 [0.5583111 ]
 [0.5451822 ]]
# xor、optimizer.Adam
[[0.01439664]
 [0.9902004 ]
 [0.99029773]
 [0.0064072 ]]

Comments

[Watching]

学習に使ってるアルゴリズムがSDGですらないただの最急降下法だから、正しい最小値に到達できていないっていうのが1番ありそうですね。XORをグラフとして考えてみると、極小値と極小値の間に山があるのが容易に想像できます…
自分のプログラムがどこか間違っているとずっと思い込んでました。
学習の方法などを変えていろいろ試してみようと思います。

[Watching]

隠れ層の活性化関数をReLUにしたところ上手くXORの学習ができました。
やった！と思って、今度は手書き数字を学習させてみると、どんな入力でも9割同じ答えになってしまうように学習されてしまう...
今度は逆にReLUからsigmoidに戻してみたらなぜか8割近い精度が出るようになり...

Answer 2

間違えたところに投稿したので削除