C++ ディープラーニングの実装に失敗します

Question

前提・実現したいこと

ゼロから作るDeepLearningを読みながらC++に変換して試しています。
第4章を実装はしたのですが数値微分での学習のため時間がかかり
確認できていません。
第5章の誤差逆伝播法を実装したのですが、学習しません。
コードを見直して、分かった範囲で修正したのですが、根本の原因が分かりません。
修正箇所を教えてください。

発生している問題・エラーメッセージ

30700 / 1000000  : (回/ループ)
損失率　=　2.35
検出
答え↓
0 0 0 0 1 0 0 0 0 0
0 1 0 0 0 0 0 0 0 0
予想↑

上記のように、予想が常に「0 1 0 0 0 0 0 0 0 0」と出ます。
また、損失率が下がりません。

該当のソースコード

行列計算クラス

matrixクラスの定義　
（行列演算クラス）

//main.cpp
constexpr void Line(int Num = 1) {
	for (int i = 0; i < Num; i++) {
		std::cout << "ーーーーーーーーーーーーーー" << std::endl;
	}
}


//出力関数
namespace Output {


	inline std::vector<double> Max_softmax(const matrix<double>& a) {
		
		std::vector<double> max;// (a[0].size(), 0);
		max.resize(a.Size_nrow());

		for (int i = 0; i < a.Size_nrow();i++) {
			max[i] = a[0][i];
		}

		for (size_t i = 0; i < a.Size_nrow(); i++) {
			for (size_t j = 0; j < a.Size_ncol(); j++) {
				if (max[i] < a[i][j]) {
					max[i] = a[i][j];
				}
			}
		}
		return max;
	}

	inline matrix<double> Softmax(const matrix<double>& a) {

		matrix<double> exp_a = a, tmp = a;
		double sum_exp_a = 0.0;
		const std::vector<double> C = Max_softmax(a);

		for (size_t i = 0; i < a.Size_nrow(); i++) {
			for (size_t j = 0; j < a.Size_ncol(); j++) {
				exp_a[i][j] = std::exp(a[i][j] - C[i]);
			}
		}

		for (size_t i = 0; i < a.Size_nrow(); i++) {
			for (size_t j = 0; j < a.Size_ncol(); j++) {
				sum_exp_a += exp_a[i][j];
			}
		}


		for (size_t i = 0; i < a.Size_nrow(); i++) {
			for (size_t j = 0; j < a.Size_ncol(); j++) {
				tmp[i][j] = exp_a[i][j] / sum_exp_a;
			}
		}

		return tmp;
	}

}

//損失関数

namespace LossFunction {
//交差エントロピー誤差
	
	double CrossEntropyError(const matrix<double>& y, const matrix<double >& t) {

		//assert(y.Size_nrow() == 1 && t.Size_nrow() == 1);
		assert(y.Size_ncol() == t.Size_ncol());

		constexpr double delta = 1e-5;

		double tmpX = 0.0;

		for (int i = 0; i < y.Size_nrow(); i++) {
			for (int j = 0; j < y.Size_ncol(); j++) {
				//数値が入っているか判定
				if (t[i][j]) {
					tmpX += t[i][j] * std::logl(y[i][j] + delta);
				}
			}
		}

		tmpX *= -1;

		return  tmpX;
	}
}

//誤差逆伝播法
namespace ErrorBack {
//layer

	class LastLayer {
	protected:
		matrix<double>* w, * b, x;
	public:
		matrix<double> dw, db;
	protected:
		matrix<double> mask;			//forwardの結果を保存
	public:
		virtual ~LastLayer() {};
		virtual matrix<double> forward(const matrix<double>&) = 0;
		virtual matrix<double> backward(const matrix<double>& dout) = 0;
	};


	//ReLUレイヤ
	class ReLU final :public LastLayer {

	public:

		matrix<double> forward(const matrix<double>& x) override {

			matrix<double> mat = x;
			mask = mat;

			for (int i = 0; i < mat.Size_nrow(); i++) {
				for (int j = 0; j < mat.Size_ncol(); j++) {
					if (0 >= mask[i][j]) {
						mat[i][j] = 0;
					}
				}
			}
			return mat;
		}

		matrix<double> backward(const matrix<double>& dout)override {

			matrix<double> dx = dout;

			for (size_t i = 0; i < dout.Size_nrow(); i++) {
				for (size_t j = 0; j < dout.Size_ncol(); j++) {
					if (0 >= mask[i][j]) {
						dx[i][j] = 0;
					}
				}
			}

			return dx;
		}
	};

//Affine
class Affine final :public LastLayer {
	public:
		Affine() = delete;

		Affine(matrix<double>* w, matrix<double>* b) { this->w = w; this->b = b; }

		matrix<double> forward(const matrix<double>& x) {

			this->x = x;

			matrix<double> out = x * *this->w + *this->b;


			return out;
		}

		matrix<double> backward(const matrix<double>& dout) {

			//1時保存
			matrix<double> W = *w, X = x;
			
			
			//回転
			W.permutation();
			X.permutation();
			

			matrix<double> dx = dout * W;
	
			this->dw = X * dout;



			std::vector<double> tmpB;

			for (int i = 0; i < dout.Size_ncol(); i++) {
				double tmp = 0.0;
				for (int j = 0; j < dout.Size_nrow(); j++) {
					tmp += dout[j][i];
				}
				tmpB.push_back(tmp);
			}

			db = matrix<double>(std::vector<std::vector<double>>(1, tmpB));

			return dx;
		}

	};


	//Softmax-with-Losslayer
	class SoftmaxWithLoss {
		matrix<double>  y, t;
		double loss;
	public:
		double forward(matrix<double>& x, const matrix<double>& t) {

			this->t = t;
			this->y = Output::Softmax(x);
			//バッチ処理
			this->loss = LossFunction::CrossEntropyError(this->y, this->t);

			return this->loss;
		}

		matrix<double> backward(double dout = 1) {

			double batch_size = t.Size_nrow();
			
			return (this->y - this->t) / batch_size;

		}
	};


	class Net {
	public:
		//種類の違う行列を入れる
		std::unordered_map<std::string, matrix<double>> params;

		//layerを入れる
		std::vector< LastLayer*> layers;


	private:
		//入力層の入力数
		const double Size_Input;
		//隠れ層のニューロン数
		const double Size_Hidden;
		//出力層のニューロン数
		const double Size_Output;
		//学習率
		const double learning_rate;

		SoftmaxWithLoss lastLayer;

	public:
		Net() = delete;

		//初期化
		/*
			引数　
			１：入力層の入力数
			２：隠れ層のニューロン数
			３：出力層のニューロン数
			４：重みを小さな値にして過学習を抑える

		*/
		Net(int input_size, int hidden_size, int output_size, double weight_init_std = 0.01)
			:Size_Input(input_size), Size_Hidden(hidden_size), Size_Output(output_size), learning_rate(weight_init_std) {


			//matrixの作成　＆　乱数をいれる
			auto F = [=](double One, double Two)->matrix<double> {

				std::vector<std::vector<double>> Vec(One, std::vector<double>(Two));

				for (auto& vec : Vec) {
					for (auto& v : vec) {
						v = ((double)rand() / RAND_MAX);
					}
				}

				return matrix<double>(Vec);
			};

						//１層目
			
			//乱数の代入 入力層×中間層の数
			params["W1"] = F(Size_Input, Size_Hidden) * learning_rate;
			//B1 「0」クリア  ：バッチサイズ×中間層の数
			params["B1"] = matrix<double>(std::vector<std::vector<double>>(1, std::vector<double>(hidden_size, 0)));

						//２層目
			
			//乱数の代入 中間層の数×出力層
			params["W2"] = F(Size_Hidden, Size_Output) * learning_rate;

			//「0」クリア  ：バッチサイズ×出力数
			params["B2"] = matrix<double>(std::vector<std::vector<double>>(1, std::vector<double>(output_size, 0)));

						//レイヤの生成
			layers.push_back(new Affine(&params["W1"], &params["B1"]));
			layers.push_back(new ReLU());
			layers.push_back(new Affine(&params["W2"], &params["B2"]));

		}

		~Net() {
			//delete Layers;

			for (auto& vec : layers) {
				delete vec;
			}
		}

		matrix<double> predict(const matrix<double>& x)const {
			auto X = x;

			for (const auto& vec : layers) {
				X = vec->forward(X);
			}
			return X;
		}

		double loss(const matrix<double>& x, const matrix<double>& t) {
			auto y = predict(x);

			return lastLayer.forward(y, t);
		}

		auto test(const matrix<double>& x, const matrix<double>& y) {
			return predict(x);
		}

		//誤差逆伝播法
		std::unordered_map<std::string, matrix<double>> gradient(const matrix<double>& x, const matrix<double>& t) {


			//forward
			loss(x, t);


			//backward
			double dout = 1.0;
			matrix<double> mdout = lastLayer.backward(dout);

			//ひっくり返す
			std::reverse(layers.begin(), layers.end());

			for (const auto& vec : layers) {
				mdout = vec->backward(mdout);
			}

			//ひっくり返す 元に戻す
			std::reverse(layers.begin(), layers.end());


			std::unordered_map<std::string, matrix<double>> grads;


			grads["W1"] = layers[0]->dw;
			grads["B1"] = layers[0]->db;
			grads["W2"] = layers[2]->dw;
			grads["B2"] = layers[2]->db;
			
			return grads;

		}

	};
}


int main() {
//誤差逆伝播法　TwoLayers
{

		constexpr	size_t  iters_num = 1000000;				//繰り返し回数
		constexpr int batch_size = 1;
		double input_size = data[0].size(), hidden_size = 3, output_size = label[0].size();
		constexpr double learning_rate = 0.001;				//学習率


		//ネットワーク
		ErrorBack::Net network(input_size, hidden_size, output_size);

		for (int i = 0; i < iters_num; i++) {
			//ミニバッチの取得
			std::vector<int> rund_batch_mask;				//乱数の数
			//乱数の取得
			for (int j = 0; j < batch_size; j++) {
				rund_batch_mask.push_back(i);
			}




			//学習データの取得
			matrix<double> x_batch(batch_size, input_size, 0);
			//正解データの保存
			matrix<double> t_batch(batch_size, output_size, 0);

			//バッチの取得
			for (int j = 0; j < batch_size; j++) {
				x_batch[j] = (data[rund_batch_mask[j]]);
				t_batch[j] = (label[rund_batch_mask[j]]);
			}



			//学習
			auto grad_backprop = network.gradient(x_batch, t_batch);

			std::vector<std::string> Key = { "W1", "B1", "W2", "B2" };
			//更新
			for (auto key : Key) {
				
				network.params[key] -= (grad_backprop[key] * learning_rate);
				
			}

			const double LOSS = network.loss(x_batch, t_batch);
			log.write(LOSS);

			//1回目のLossで（更新後）エラーでる
			if ((i + 1) % 100 == 0 || i == 0) {


				std::cout << i + 1 << " / " << iters_num << "  : (回/ループ)" << std::endl;
				std::cout << "損失率　=　" <<LOSS << std::endl;
				std::cout << "検出" << std::endl;

				auto F = Output::Softmax(network.test(x_batch, t_batch));
				
				std::cout << "答え↓" << std::endl;
				t_batch.show();


				double kk = 0.0;
				for (int j = 0; j < F.Size_nrow(); j++) {
					for (int k = 0; k < F.Size_ncol(); k++) {
						if (kk < F[j][k]) {
							kk = k;
						}
						F[j][k] = 0;
					}
				}

				F[0][kk] = 1;
				for (int j = 0; j < F.Size_nrow(); j++) {
					for (int k = 0; k < F.Size_ncol(); k++) {

						std::cout << F[j][k] << " ";

					}
				}
				std::cout << std::endl << "予想↑" << std::endl;

				std::cout << std::endl;

				Line(2);
			}
		}
	}
}

試したこと

AFFINEクラス、ReLu関数、Softmax-with-Lossクラスの
forward関数、backward関数の出力結果が正しいか確認しましたが
問題はなかった。

補足情報（FW/ツールのバージョンなど）

C++17
VisualStudio2019

Comments

[jbpb0]

変換しているのが勉強のためなら、以下スルーしてください

cythonで変換できるかもしれません
pythonのコードをちょっと修正(変数の型宣言、import→cimport等)し、
https://www.sejuku.net/blog/60454#Cython-5
https://yutori-datascience.hatenablog.com/entry/2017/08/17/203143#%E4%BD%BF%E3%81%84%E6%96%B9-%E3%81%9D%E3%81%AE1-Cython%E5%AE%9F%E8%A3%85
変換する
https://miyabikno-jobs.com/cython-compile-cythonize/#cython%E5%8F%8A%E3%81%B3cythonize%E3%82%92%E4%BD%BF%E7%94%A8%E3%81%97%E3%81%9F%E3%82%B3%E3%83%B3%E3%83%91%E3%82%A4%E3%83%AB%E6%96%B9%E6%B3%95

Answer 1

見直したら、複数個所でコードミスがありました。
修正したら学習しました。
１．Sigmoid関数でバッチ対応していませんでした
２．AffineクラスでB１・B2の足算でミスがありました（Matrixクラス）
３．クロスエントロピー誤差の戻り値でバッチ数での割算を忘れていました。
４．「0 1 0 0 0 0 0 0 0 0」と表示されるのは、コードミスでした。

ありがとうございます