ディープラーニングでの結果と損失率が正しく出力されません

Question

ゼロから作るDeepLearning　を読んで、C＋＋とCUDAで作成しています。
誤差逆伝播の実装において、異なる画像データを入力しても、softmax関数の出力結果が常に同じ値になってしまします。
また損失関数の値も、最初は小さくなっていくのですが、
２～３の間で下がりません。もしくは、乱数によっては、一定まで下がったら
急に損失率があがり、infを返します。
その時の出力結果は、10個のうち一つを「１」と返してきます。

添付画像では、損失関数とsoftmax関数の出力結果と正解データになります。

Affineレイヤー
Reluレイヤー
Softmaxレイヤー
の実装が間違っていると思い、
手計算できる行列で、電卓を使いながら計算して追いかけましたが、
出力結果は正しかったです。

重み・バイアスの更新時になにか注意することなどがあるのでしょうか？
原因を教えてください。

//行列classになります。
//行列の四則演算をCUDAで計算させています。
//四則演算は電卓を使って、正しい答えが出る事を確認してあります。
#pragma once


namespace GPU {
	
　　　　　//オペレータでデバイスメモリを取得できる
	class matrix final {
　　　　　　double* m{ nullptr };							//GPU側配列
publci:
//GPU配列のポインタを取得
 operator double* ()const { return m; };
		
//省略
}

layerを作る為のCUDA定義・宣言

///////////////////////////////
//ReLU関数  0以上はそのまま返す
///////////////////////////////
/*
        { ( x > 0 )  =  x
 h(x) = {  
        { ( x <= 0 ) = 0
*/
__global__ void ReLU(double* m, double* out, size_t size);

__global__ void backReLU(double* m, double* out, size_t size);

//////////////////////////////////////////////
//出力関数　　（出力値が高い奴が　正解　と判定）
/////////////////////////////////////////////
//ソフトマックス関数
/*
		　　　   exp(a[k] + C)
	y[k] = ーーーーーーーーーー
				 n
				∑ exp(a[i] + C)
				i=1
*/
__global__ void SOFTMAX(double* m, size_t row,size_t col,  double* out);


////////////////
//行列の列を足す
////////////////

__global__ void Matrix_col_Sum(double* x, double* y, int col_size, int size);

//定義

/////////////
//活性化関数
/////////////

//ReLU関数  0以上はそのまま返す
__global__ void ReLU(double* m,double* out, size_t size) {

	unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;

	while (size > x) {

		if (m[x] < 0) {
			out[x] = 0;
		}
		else {
			out[x] = m[x];
		}

		x += blockDim.x * gridDim.x;
	}

	return;
}

__global__ void backReLU(double* m, double* out, size_t size) {

	unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;

	while (size > x) {

		if (m[x] <= 0) {
			out[x] = 0;
		}
		x += blockDim.x * gridDim.x;
	}

	return;
}


///////////////////////

//ソフトマックス関数

// <<<1,行数>>> で使用する  //行分の並列
__global__ void SOFTMAX(double* m, size_t row, size_t col, double* out) {

	unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
	
	while (row > x) {

		double* exp_a = new double[col];
		double sum_exp_a = 0.0;

		//最初の要素を入れる
		double tmp = m[x];

		//要素の最大を取得
		for (int i = 0; i < col; i++) {
			if (tmp < m[(row * i) + x]) {
				tmp = m[(row * i) + x];
			}
		}

		//exp(a[k])
		for (int i = 0; i < col; i++) {
			exp_a[i] = exp(m[(row * i) + x] - tmp);
		}


		for (int i = 0; i < col; i++) {
			sum_exp_a += exp(m[(row * i) + x] - tmp);
		}

		for (int i = 0; i < col; i++) {
			out[(row * i) + x] = exp_a[i] / sum_exp_a;
		}

		delete[] exp_a;

		x += blockDim.x * gridDim.x;
	}
}


//クロスエントロピー誤差

double CrossEntropyError(GPU::matrix& y, GPU::matrix& t) {

	double sum = 0.0;

	
	auto pY = y.read_vec2();
	auto pT = t.read_vec2();

	for (int i = 0; i < y.col(); i++) {
		for (int j = 0; j < y.row(); j++) {
			if (pT[j][i] != 0) {
				sum += pT[j][i] * std::log(pY[j][i]);
			}
		}
		
	}


	return -sum / y.row();
}


/////////////////
//行列の列を足す
////////////////

// 1 入力　２　出力　３　行数　４行列サイズ     << <1, 列数 >> >
__global__ void Matrix_col_Sum(double* X, double* y, int row_size, int col_size) {

	unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
	int n2 = x * row_size;

	y[x] = 0.0;


	while (col_size > x) {

		for (int i = 0; i < row_size; i++) {
			y[x] += X[n2 + i ];
		}

			x += blockDim.x * gridDim.x;
	}
}

各レイヤー

class Affine {
		GPU::matrix* w, * b;
		GPU::matrix x;
		GPU::matrix dw, db;
	public:
		Affine() = delete;
		Affine(GPU::matrix* w, GPU::matrix* b) :w(w), b(b) {};

		GPU::matrix forward(GPU::matrix* x) {
			this->x = *x;
			return (this->x * (*w)) + (*b);
		}

		GPU::matrix backward(GPU::matrix* dout) {
			auto Wt = *this->w;
			Wt.permutation();
			auto dx = (*dout) * Wt;

			auto Xt = this->x;
			Xt.permutation();
			this->dw = Xt * (*dout);

			db.resize_write(1, dout->col());
			//列で加算する
			Matrix_col_Sum << <1, dout->col() >> >
				(*dout, this->db, dout->row(), dout->col());
			cudaThreadSynchronize();
			return dx;
		}

		GPU::matrix get_dw() { return dw; };
		GPU::matrix get_db() { return db; };

	};

class Relu {
		GPU::matrix data;
	public:
		Relu() {}

		GPU::matrix forward(GPU::matrix* x) {
			data = *x;

			const int n2 = x->row() * x->col();

			ReLU
				<< < (n2 + g_inf.prop->maxThreadsDim[0] - 1) / g_inf.prop->maxThreadsDim[0], g_inf.prop->maxThreadsDim[0] >> >
				(*x, data, n2);
			cudaThreadSynchronize();
			return data;
		}

		GPU::matrix backward(GPU::matrix* dout) {

			GPU::matrix dx = *dout;

			const int n2 = dx.row() * dx.col();
			backReLU
				<< < (n2 + g_inf.prop->maxThreadsDim[0] - 1) / g_inf.prop->maxThreadsDim[0], g_inf.prop->maxThreadsDim[0] >> >
				(data, dx, n2);
			cudaThreadSynchronize();
			return dx;
		}

	};

class SoftmaxWithLoss {

		double loss{ NULL };
		
		GPU::matrix y, t;
	public:


		double forward(GPU::matrix* x, GPU::matrix* t) {


			y.resize_write(x->row(), x->col(), 0);

			SOFTMAX << < 1, x->row() >> >
				(*x, x->row(), x->col(), y);
			cudaThreadSynchronize(); 

			this->t = *t;

			this->loss = CrossEntropyError(y, *t);

			return this->loss;
		}

		GPU::matrix Out(GPU::matrix* x, GPU::matrix* t) {

			y.resize_write(x->row(), x->col(), 0);

			SOFTMAX << < 1, x->row() >> >
				(*x, x->row(), x->col(), y);
			cudaThreadSynchronize();

			
			return y;
		}

		GPU::matrix backward(double dout = 1) {
			double batch_size = t.row();
			return (this->y - this->t) / batch_size;

		}

	};

main関数のでの処理

「画像データ読み込み」関数を作って、data,lavel,testdata,testlabelに読み込みこんでいます。
「g_Log->・・・」はログを取る為にテキストファイルに書き込んでいます。

////////////////
//FILE読込
////////////////
		//省略 
                //vector<vector>で　data　、　label　に入っている

		
		constexpr	size_t  iters_num = 10000;				//繰り返し回数
		constexpr int batch_size = 25;
		constexpr double learning_rate = 0.01;				//学習率
		const double input_size = data[0].size(), hidden_size = 50, output_size = label[0].size();


	//損失関数の出力を入れる
		std::list<double> lossList;


//行列の作成
//W：重みは正規分布に従って乱数生成
//b：０で初期化
		GPU::matrix AffineVectorW1(W1, input_size, hidden_size);
		GPU::matrix AffineVectorB1(1, hidden_size, 0);
		GPU::matrix AffineVectorW2(W2, hidden_size, output_size);
		GPU::matrix AffineVectorB2(1, output_size, 0);
		AffineVectorW1 *= learning_rate;
		AffineVectorW2 *= learning_rate;

//レイヤーの作成
		Test2Network::Affine ClassAffine1(&AffineVectorW1, &AffineVectorB1);
		Test2Network::Relu ClassRelu;
		Test2Network::Affine ClassAffine2(&AffineVectorW2, &AffineVectorB2);
		Test2Network::SoftmaxWithLoss ClassSoftmax;
//損失が0.8未満になるまでループ
		for (int i=0;;i++) {

			//ミニバッチの乱数取得
			std::vector<int> rund_batch_mask, rund_testBatch_mask;				//乱数を入れる


		//乱数生成器
			std::random_device rnd;								// 非決定的な乱数生成器を生成
			std::mt19937 mt(rnd());								//  メルセンヌ・ツイスタの32ビット版、引数は初期シード値
			std::uniform_int_distribution<> rand100(0, data.size() - 1);	// [0, 60000] 範囲の一様乱数
			std::uniform_int_distribution<> rand_testData(0, testdata.size() - 1);	// [0, testデータサイズ] 範囲の一様乱数


			//乱数の取得
			for (int j = 0; j < batch_size; j++) {
				rund_batch_mask.push_back(rand100(mt));
				rund_testBatch_mask.push_back(rand_testData(mt));
			}

			std::vector<std::vector<double>> X_batch(batch_size, std::vector<double>(input_size, 0));
			std::vector<std::vector<double>> T_batch(batch_size, std::vector<double>(output_size, 0));
			


			//無作為にデータを取得
			for (int j = 0; j < batch_size; j++) {
					X_batch[j] = data[rund_batch_mask[j]];
　　　　　　　}

			//正解データを無作為に取得
			for (int j = 0; j < batch_size; j++) {
				T_batch[j] = label[rund_batch_mask[j]];
			}


			//学習データの取得
			GPU::matrix x_batch(X_batch);

			//正解データの保存
			GPU::matrix t_batch(T_batch);

			

//ここからディープラーニング

			//std::wcout << L" X" << std::endl;
			//x_batch.show();
			//std::wcout << L" W1" << std::endl;
			//AffineVectorW1.show();
			auto Aff1 = ClassAffine1.forward(&x_batch);


			//std::wcout << L" Aff1" << std::endl;
			//Aff1.show();
			auto Relu1 = ClassRelu.forward(&Aff1);

			//std::wcout << L" Relu1" << std::endl;
			//Relu1.show();


			//std::wcout << L" W2" << std::endl;
			//AffineVectorW2.show();
			auto Aff2 = ClassAffine2.forward(&Relu1);

			//Aff2.show();
			double loss = ClassSoftmax.forward(&Aff2, &t_batch);

			lossList.push_back(loss);

			//std::wcout << L"バックワード" << std::endl;

			auto last = ClassSoftmax.backward(1);
			//last.show();

			auto last2 = ClassAffine2.backward(&last);
			//last2.show();

			auto last3 = ClassRelu.backward(&last2);
			//last3.show();

			auto last4 = ClassAffine1.backward(&last3);
			//last4.show();

　　　　　　　//更新
			AffineVectorW1 -= ClassAffine1.get_dw() * learning_rate;
			AffineVectorB1 -= ClassAffine1.get_db() * learning_rate;
			AffineVectorW2 -= ClassAffine2.get_dw() * learning_rate;
			AffineVectorB2 -= ClassAffine2.get_db() * learning_rate;

			if ((i % 4000) == 0) {
				std::wcout << L"損失 : " << loss << std::endl;
				std::wcout << L"予測" << std::endl;
				ClassSoftmax.Out(&Aff2, &t_batch).show();
				std::wcout << L"正解" << std::endl;
				t_batch.show();
			
				std::wcout << L"ーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーーー" << std::endl;
			}

			if (loss < 0.8) {
				break;
			}

		}

Comments

[jbpb0]

画像の値は正規化してますでしょうか？

同じ計算をCUDAを使わずCPUのみで行った場合は、正常に学習できるのでしょうか？

Answer 1

・学習データにおかしいサンプルが混ざってるかチェック
・勾配をチェック
すれば対応できるかと思います