C++卷积神经网络

于 2023-08-26 16:35:14 发布
阅读量1.5k 收藏 7
点赞数 4
分类专栏： C++ 神经网络 文章标签： c++ cnn 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42877866/article/details/132513172
版权

C++卷积神经网络

#include"TP_NNW.h"
#include<iostream>
#pragma warning(disable:4996)
using namespace std;
using namespace mnist;

float* SGD(Weight* W1, Weight& W5, Weight& Wo, float** X)
{
	Vector2 ve(28, 28);
	float* temp = new float[10];
	Vector2 Cout;
	float*** y1 = Conv(X, ve, Cout, W1, 20);
	for (int i = 0; i < 20; i++)
		for (int n = 0; n < Cout.height; n++)
			for (int m = 0; m < Cout.width; m++)
				y1[i][n][m] = ReLU(y1[i][n][m]);
	float*** y2 = y1;
	Vector2 Cout2;
	float*** y3 = Pool(y1, Cout, 20, Cout2);
	float* y4 = reshape(y3, Cout2, 20, true);
	float* v5 = dot(W5, y4);
	float* y5 = ReLU(v5, W5);
	float* v = dot(Wo, y5);
	float* y = Softmax(v, Wo);
	for (int i = 0; i < Wo.len.height; i++)
		temp[i] = y[i];
	return temp;
}
void trainSGD(Weight* W1, Weight& W5, Weight& Wo, FILE* fp, FILE* tp)
{
	Vector2 ve(28, 28);
	unsigned char* reader = new unsigned char[ve.height * ve.width];
	float** X = apply2(ve.height, ve.width);
	unsigned char hao;
	hot_one<char> D(10);

	Weight* momentum1 = new Weight[20];//动量
	Weight momentum5;
	Weight momentumo;
	Weight* dW1 = new Weight[20];//动量
	Weight dW5;
	Weight dWo;
	for (int i = 0; i < 20; i++)
		W1[0] >> momentum1[i];
	W5 >> momentum5;
	Wo >> momentumo;
	int N = 8000;//训练集取前8000个
	int bsize = 100;//100个纠正一次
	int b_len;
	int* blist = bList(bsize, N, &b_len);
	for (int batch = 0; batch < b_len; batch++)
	{
		for (int i = 0; i < 20; i++)
			W1[0] >> dW1[i];
		W5 >> dW5;
		Wo >> dWo;
		int begins = blist[batch];
		for (int k = begins; k < begins + bsize && k < N; k++)
		{
			::fread(reader, sizeof(unsigned char), ve.height * ve.width, fp);//读取图像
			Toshape2(X, reader, ve);//组合成二维数组
			Vector2 Cout;//储存卷积后数组的尺寸  20
			float*** y1 = Conv(X, ve, Cout, W1, 20);//卷积
			for (int i = 0; i < 20; i++)
				for (int n = 0; n < Cout.height; n++)
				{
					for (int m = 0; m < Cout.width; m++)
					{
						y1[i][n][m] = ReLU(y1[i][n][m]);//通过ReLU函数
					}
				}
			float*** y2 = y1;//给变量y2
			Vector2 Cout2;//记录池化后的尺寸   10
			float*** y3 = Pool(y1, Cout, 20, Cout2);//池化层
			float* y4 = reshape(y3, Cout2, 20, true);//作为神经元输入
			float* v5 = dot(W5, y4);//矩阵乘法
			float* y5 = ReLU(v5, W5);//ReLU函数
			float* v = dot(Wo, y5);//举证乘法
			float* y = Softmax(v, Wo);//soft分类
			::fread(&hao, sizeof(unsigned char), 1, tp);//读取标签
			D.re(hao);
			float* e = new float[10];
			for (int i = 0; i < 10; i++)
				e[i] = ((float)D.one[i]) - y[i];
			float* delta = e;
			float* e5 = FXCB_err(Wo, delta);
			float* delta5 = Delta2(y5, e5, W5);
			float* e4 = FXCB_err(W5, delta5);
			float*** e3 = Toshape3(e4, 20, Cout2);
			float*** e2 = apply3(20, Cout.height, Cout.width);
			Weight one(2, 2, ones);
			/*for (int i = 0; i < 20; i++)
			{
				::printf("第%d层\n", i);
				for (int n = 0; n < Cout2.height; n++)
				{
					for (int m = 0; m < Cout2.width; m++)
						::printf("%0.3f ", e3[i][n][m]);
					puts("");
				}
			}
			getchar();*/
			for (int i = 0; i < 20; i++)//---------------------------------
				kron(e2[i], Cout, e3[i], Cout2, one.WG, one.len);

			/*for (int i = 0; i < 20; i++)
			{
				::printf("第%d层\n", i);
				for (int n = 0; n < Cout.height; n++)
				{
					for (int m = 0; m < Cout.width; m++)
						::printf("%f ", e2[i][n][m]);
					puts("");
				}
			}
			getchar();*/

			float*** delta2 = apply3(20, Cout.height, Cout.width);
			for (int i = 0; i < 20; i++)
				for (int n = 0; n < Cout.height; n++)
					for (int m = 0; m < Cout.width; m++)
						delta2[i][n][m] = (y2[i][n][m] > 0) * e2[i][n][m];
			float*** delta_x = (float***)malloc(sizeof(float***) * 20);
			Vector2 t1;
			for (int i = 0; i < 20; i++)
				delta_x[i] = conv2(X, ve, delta2[i], Cout, &t1);
			for (int i = 0; i < 20; i++)
				for (int n = 0; n < t1.height; n++)
					for (int m = 0; m < t1.width; m++)
						dW1[i].WG[n][m] += delta_x[i][n][m];
			dW5.re(delta5, y4, 1);
			dWo.re(delta, y5, 1);

			Free3(delta_x, 20, t1.height);
			Free3(delta2, 20, Cout.height);
			one.release();
			Free3(e2, 20, Cout.height);
			Free3(e3, 20, Cout2.height);
			free(e4);
			free(delta5);
			free(e5);
			free(v5);
			delete e;
			free(y5);
			free(v);
			free(y);
			Free3(y1, 20, Cout.height);
			free(y4);
		}
		for (int i = 0; i < 20; i++)
			dW1[i] /= (bsize);
		dW5 /= (bsize);
		dWo /= (bsize);
		for (int i = 0; i < 20; i++)
			for (int n = 0; n < W1[0].len.height; n++)
				for (int m = 0; m < W1[0].len.width; m++)
				{
					momentum1[i].WG[n][m] = ALPHA * dW1[i].WG[n][m] + BETA * momentum1[i].WG[n][m];
					W1[i].WG[n][m] += momentum1[i].WG[n][m];
				}
		for (int n = 0; n < W5.len.height; n++)
			for (int m = 0; m < W5.len.width; m++)
				momentum5.WG[n][m] = ALPHA * dW5.WG[n][m] + BETA * momentum5.WG[n][m];
		W5 += momentum5;
		for (int n = 0; n < Wo.len.height; n++)
			for (int m = 0; m < Wo.len.width; m++)
				momentumo.WG[n][m] = ALPHA * dWo.WG[n][m] + BETA * momentumo.WG[n][m];
		Wo += momentumo;

	}
	for (int i = 0; i < 20; i++)
	{
		momentum1[i].release();
		dW1[i].release();
	}
	momentum5.release();
	momentumo.release();
	Free2(X, ve.height);
	free(blist);
	delete reader;
	D.release();
	dW5.release();
	dWo.release();
	return;
}
void trainSGD1(Weight* W1, Weight& W5, Weight& Wo, FILE* fp, FILE* tp)
{
	Vector2 ve(28, 28);
	unsigned char* reader = new unsigned char[ve.height * ve.width];
	float** X = apply2(ve.height, ve.width);
	unsigned char hao;
	hot_one<char> D(10);

	Weight* momentum1 = new Weight[20];//动量
	Weight momentum5;
	Weight momentumo;
	Weight* dW1 = new Weight[20];//动量
	Weight dW5;
	Weight dWo;
	for (int i = 0; i < 20; i++)
		W1[0] >> momentum1[i];
	W5 >> momentum5;
	Wo >> momentumo;
	int N = 108;//训练集取前8000个
	int bsize = 12;//100个纠正一次
	int b_len;
	int* blist = bList(bsize, N, &b_len);
	for (int batch = 0; batch < b_len; batch++)
	{
		for (int i = 0; i < 20; i++)
			W1[0] >> dW1[i];
		W5 >> dW5;
		Wo >> dWo;
		int begins = blist[batch];
		for (int k = begins; k < begins + bsize && k < N; k++)
		{
			::fread(reader, sizeof(unsigned char), ve.height * ve.width, fp);//读取图像
			Toshape2(X, reader, ve);//组合成二维数组
			Vector2 Cout;//储存卷积后数组的尺寸  20
			float*** y1 = Conv(X, ve, Cout, W1, 20);//卷积
			for (int i = 0; i < 20; i++)
				for (int n = 0; n < Cout.height; n++)
				{
					for (int m = 0; m < Cout.width; m++)
					{
						y1[i][n][m] = ReLU(y1[i][n][m]);//通过ReLU函数
					}
				}
			float*** y2 = y1;//给变量y2
			Vector2 Cout2;//记录池化后的尺寸   10
			float*** y3 = Pool(y1, Cout, 20, Cout2);//池化层
			float* y4 = reshape(y3, Cout2, 20, true);//作为神经元输入
			float* v5 = dot(W5, y4);//矩阵乘法
			float* y5 = ReLU(v5, W5);//ReLU函数
			float* v = dot(Wo, y5);//举证乘法
			float* y = Softmax(v, Wo);//soft分类
			::fread(&hao, sizeof(unsigned char), 1, tp);//读取标签
			D.re(hao);
			float* e = new float[10];
			for (int i = 0; i < 10; i++)
				e[i] = ((float)D.one[i]) - y[i];
			float* delta = e;
			float* e5 = FXCB_err(Wo, delta);
			float* delta5 = Delta2(y5, e5, W5);
			float* e4 = FXCB_err(W5, delta5);
			float*** e3 = Toshape3(e4, 20, Cout2);
			float*** e2 = apply3(20, Cout.height, Cout.width);
			Weight one(2, 2, ones);
			/*for (int i = 0; i < 20; i++)
			{
			::printf("第%d层\n", i);
			for (int n = 0; n < Cout2.height; n++)
			{
			for (int m = 0; m < Cout2.width; m++)
			::printf("%0.3f ", e3[i][n][m]);
			puts("");
			}
			}
			getchar();*/
			for (int i = 0; i < 20; i++)//---------------------------------
				kron(e2[i], Cout, e3[i], Cout2, one.WG, one.len);

			/*for (int i = 0; i < 20; i++)
			{
			::printf("第%d层\n", i);
			for (int n = 0; n < Cout.height; n++)
			{
			for (int m = 0; m < Cout.width; m++)
			::printf("%f ", e2[i][n][m]);
			puts("");
			}
			}
			getchar();*/

			float*** delta2 = apply3(20, Cout.height, Cout.width);
			for (int i = 0; i < 20; i++)
				for (int n = 0; n < Cout.height; n++)
					for (int m = 0; m < Cout.width; m++)
						delta2[i][n][m] = (y2[i][n][m] > 0) * e2[i][n][m];
			float*** delta_x = (float***)malloc(sizeof(float***) * 20);
			Vector2 t1;
			for (int i = 0; i < 20; i++)
				delta_x[i] = conv2(X, ve, delta2[i], Cout, &t1);
			for (int i = 0; i < 20; i++)
				for (int n = 0; n < t1.height; n++)
					for (int m = 0; m < t1.width; m++)
						dW1[i].WG[n][m] += delta_x[i][n][m];
			dW5.re(delta5, y4, 1);
			dWo.re(delta, y5, 1);

			Free3(delta_x, 20, t1.height);
			Free3(delta2, 20, Cout.height);
			one.release();
			Free3(e2, 20, Cout.height);
			Free3(e3, 20, Cout2.height);
			free(e4);
			free(delta5);
			free(e5);
			free(v5);
			delete e;
			free(y5);
			free(v);
			free(y);
			Free3(y1, 20, Cout.height);
			free(y4);
		}
		for (int i = 0; i < 20; i++)
			dW1[i] /= (bsize);
		dW5 /= (bsize);
		dWo /= (bsize);
		for (int i = 0; i < 20; i++)
			for (int n = 0; n < W1[0].len.height; n++)
				for (int m = 0; m < W1[0].len.width; m++)
				{
					momentum1[i].WG[n][m] = ALPHA * dW1[i].WG[n][m] + BETA * momentum1[i].WG[n][m];
					W1[i].WG[n][m] += momentum1[i].WG[n][m];
				}
		for (int n = 0; n < W5.len.height; n++)
			for (int m = 0; m < W5.len.width; m++)
				momentum5.WG[n][m] = ALPHA * dW5.WG[n][m] + BETA * momentum5.WG[n][m];
		W5 += momentum5;
		for (int n = 0; n < Wo.len.height; n++)
			for (int m = 0; m < Wo.len.width; m++)
				momentumo.WG[n][m] = ALPHA * dWo.WG[n][m] + BETA * momentumo.WG[n][m];
		Wo += momentumo;

	}
	for (int i = 0; i < 20; i++)
	{
		momentum1[i].release();
		dW1[i].release();
	}
	momentum5.release();
	momentumo.release();
	Free2(X, ve.height);
	free(blist);
	delete reader;
	D.release();
	dW5.release();
	dWo.release();
	return;
}
float rand1()
{
	float temp = (rand() % 20) / (float)10;
	if (temp < 0.0001)
		temp = 0.07;
	temp *= (rand() % 2 == 0) ? -1 : 1;
	return temp * 0.01;
}
float rand2()
{
	float temp = (rand() % 10) / (float)10;
	float ret = (2 * temp - 1) * sqrt(6) / sqrt(360 + 2000);
	if (ret < 0.0001 && ret>-0.0001)
		ret = 0.07;
	return ret;
}
float rand3()
{
	float temp = (rand() % 10) / (float)10;
	float ret = (2 * temp - 1) * sqrt(6) / sqrt(10 + 100);
	if (ret < 0.0001 && ret>-0.0001)
		ret = 0.07;
	return ret;
}

void train()
{
	FILE* fp = fopen("t10k-images.idx3-ubyte", "rb");
	FILE* tp = fopen("t10k-labels.idx1-ubyte", "rb");
	int rdint;
	::fread(&rdint, sizeof(int), 1, fp);
	::printf("训练集幻数：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, fp);
	::printf("训练集数量：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, fp);
	::printf("训练集高度：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, fp);
	::printf("训练集宽度：%d\n", ReverseInt(rdint));
	int start1 = ftell(fp);
	::fread(&rdint, sizeof(int), 1, tp);
	::printf("标签幻数：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, tp);
	::printf("标签数量：%d\n", ReverseInt(rdint));
	int start2 = ftell(tp);
	Weight* W1 = new Weight[20];
	WD(W1, 9, 9, 20, rand1);
	Weight W5(100, 2000, rand2);
	Weight Wo(10, W5.len.height, rand3);
	for (int k = 0; k < 3; k++)
	{
		trainSGD(W1, W5, Wo, fp, tp);
		fseek(fp, start1, 0);
		fseek(tp, start2, 0);
		::printf("第%d次训练结束\n", k + 1);
	}
	fclose(fp);
	fclose(tp);
	fp = fopen("mnist_Weight.acp", "wb");
	for (int i = 0; i < 20; i++)
		W1[i].save(fp);
	W5.save(fp);
	Wo.save(fp);
	fclose(fp);
	::printf("训练完成");
	getchar();
}
void train1()
{
	FILE* fp = fopen("out_img.acp", "rb");
	FILE* tp = fopen("out_label.acp", "rb");
	int rdint;
	::fread(&rdint, sizeof(int), 1, fp);
	::printf("训练集幻数：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, fp);
	::printf("训练集数量：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, fp);
	::printf("训练集高度：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, fp);
	::printf("训练集宽度：%d\n", ReverseInt(rdint));
	int start1 = ftell(fp);
	::fread(&rdint, sizeof(int), 1, tp);
	::printf("标签幻数：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, tp);
	::printf("标签数量：%d\n", ReverseInt(rdint));
	int start2 = ftell(tp);
	Weight* W1 = new Weight[20];
	WD(W1, 9, 9, 20, rand1);
	Weight W5(100, 2000, rand2);
	Weight Wo(10, W5.len.height, rand3);
	for (int k = 0; k < 1000; k++)
	{
		trainSGD1(W1, W5, Wo, fp, tp);
		fseek(fp, start1, 0);
		fseek(tp, start2, 0);
		::printf("第%d次训练结束\n", k + 1);
	}
	fclose(fp);
	fclose(tp);
	fp = fopen("mnist_Weight.acp", "wb");
	for (int i = 0; i < 20; i++)
		W1[i].save(fp);
	W5.save(fp);
	Wo.save(fp);
	fclose(fp);
	::printf("训练完成");
	getchar();
}
void test()
{
	FILE* fp = fopen("mnist_Weight.acp", "rb");
	Weight* W1 = new Weight[20];
	WD(W1, 9, 9, 20, rand1);
	Weight W5(100, 2000, rand1);
	Weight Wo(10, W5.len.height, rand1);
	for (int i = 0; i < 20; i++)
		W1[i].load(fp);
	W5.load(fp);
	Wo.load(fp);
	fclose(fp);
	fp = fopen("t10k-images.idx3-ubyte", "rb");
	FILE* tp = fopen("t10k-labels.idx1-ubyte", "rb");
	int rdint;
	::fread(&rdint, sizeof(int), 1, fp);
	::printf("训练集幻数：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, fp);
	::printf("训练集数量：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, fp);
	::printf("训练集高度：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, fp);
	::printf("训练集宽度：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, tp);
	::printf("标签幻数：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, tp);
	::printf("标签数量：%d\n", ReverseInt(rdint));
	unsigned char* res = new unsigned char[28 * 28];
	float** X = apply2(28, 28);
	unsigned char biaoqian;
	Vector2 t2828 = Vector2(28, 28);
	for (int i = 0; i < 50; i++)
	{
		::fread(res, sizeof(unsigned char), 28 * 28, fp);
		Toshape2(X, res, 28, 28);
		print(X, t2828);
		float* h = SGD(W1, W5, Wo, X);//带入神经网络
		int c = -1;
		for (int i = 0; i < 10; i++)
		{
			if (h[i] > 0.85)
			{
				c = i;
				break;
			}
		}
		::fread(&biaoqian, sizeof(unsigned char), 1, tp);
		::printf("正确结果应当为“%d”,      神经网络识别为“%d”   \n", biaoqian, c);
	}
}
void sb()
{

	Weight* W1;
	Weight W5(100, 2000, rand2);
	Weight Wo(10, W5.len.height, rand3);
	//::printf("加载权重完毕\n");
	Vector2 out;
	char path[256];
	for (int r = 0; r < 4; r++)
	{
		sprintf(path, "acp%d.png", r);
		float** img = Get_data_by_Mat(path, out);
		//print(img, out);
		float* h = SGD(W1, W5, Wo, img);//带入神经网络
		int c = -1;
		float x = 0;
		for (int i = 0; i < 10; i++)
		{
			if (h[i] > 0.85 && h[i] > x)
			{
				x = h[i];
				c = i;
			}
		}
		::printf("%d ", c);
		Free2(img, out.height);
		free(h);
		remove(path);
	}
	puts("");
}

void sb(char* path)
{
	Weight* W1 = new Weight[20];
	Weight W5(100, 2000, rand2);
	Weight Wo(10, W5.len.height, rand3);
	FILE* fp = fopen("mnist_Weight.acp", "rb");
	puts("开始加载权重");
	WD(W1, 9, 9, 20, rand1);
	for (int i = 0; i < 20; i++)
		W1[i].load(fp);
	W5.load(fp);
	Wo.load(fp);
	fclose(fp);
	::printf("加载权重完毕\n");
	Vector2 out;
	float** img = Get_data_by_Mat(path, out);
	printf("图像载入完毕");
	//print(img, out);
	float* h = SGD(W1, W5, Wo, img);//带入神经网络
	int c = -1;
	float max = -1;
	for (int i = 0; i < 10; i++)
	{
		::printf("%f\n", h[i]);
		/*if (h[i] > 0.65 && h[i] > x)
		{
			x = h[i];
			c = i;
		}*/
		if (max< h[i])
		{
			max = h[i];
			c = i;
		}
	}
	::printf("神经网络认为它是数字-->%d   相似度为：%f", c, max);
	Free2(img, out.height);
	free(h);

}
bool thank(int x1,int x2, int y1, int y2, int z1, int z2 )
{
	int dis = 0;
	int xx = (x1 - x2);
	dis += xx * xx;
	xx = (y1 - y2);
	dis += xx * xx;
	xx = (z1 - z2);
	dis += xx * xx;
	dis = (int)sqrt(dis);
	if (dis < 100)
		return true;
	return false;
}
void qg(char* path)
{
	::printf(path);
	::printf("识别为：");
	//Mat img = imread(path);
	CImage img;
	img.Load(path);
	//Vec3b yes = Vec3b(204, 198, 204);
	CImage sav;// = Mat(120, 80, CV_8UC3);
	sav.Create(120, 80, 24);
	ResizeCImage(img, img.GetWidth() * 10, img.GetHeight() * 10);
	int XS = img.GetBPP() / 8;
	int pitch = img.GetPitch();
	//resize(img, img, Size(img.cols * 10, img.rows * 10));
	unsigned char* rgb = (unsigned char*)img.GetBits();
	for (int i = 0; i < img.GetHeight(); i++)
		for (int j = 0; j < img.GetWidth(); j++)
		{
			//Vec3b rgb = img.at<Vec3b>(i, j);
			int x1= *(rgb + (j * XS) + (i * pitch) + 0);
			int y1 = *(rgb + (j * XS) + (i * pitch) + 1);
			int z1 = *(rgb + (j * XS) + (i * pitch) + 2);
			if (thank(x1, 204, y1, 198, z1, 204))
			{
				*(rgb + (j * XS) + (i * pitch) + 0) = 255;
				*(rgb + (j * XS) + (i * pitch) + 1) = 255;
				*(rgb + (j * XS) + (i * pitch) + 2) = 255;
				//img.at<Vec3b>(i, j) = Vec3b(255, 255, 255);
			}
			/*else
				img.at<Vec3b>(i, j) = Vec3b(0, 0, 0);*/
		}
	/*char p[256];
	for (int k = 0; k < 4; k++)
	{
		sprintf(p, "acp%d.png", k);
		for (int i = 35 + (k * 80); i < 115 + (k * 80); i++)
			for (int j = 30; j < 150; j++)
				sav.at<Vec3b>(j - 30, i - (35 + (k * 80))) = img.at<Vec3b>(j, i);
		imwrite(p, sav);
	}
	img.release();
	sav.release();*/
	sb();
}
void test1()
{
	FILE* fp = fopen("mnist_Weight.acp", "rb");
	Weight* W1 = new Weight[20];
	WD(W1, 9, 9, 20, rand1);
	Weight W5(100, 2000, rand1);
	Weight Wo(10, W5.len.height, rand1);
	for (int i = 0; i < 20; i++)
		W1[i].load(fp);
	W5.load(fp);
	Wo.load(fp);
	fclose(fp);
	fp = fopen("out_img.acp", "rb");
	FILE* tp = fopen("out_label.acp", "rb");
	int rdint;
	::fread(&rdint, sizeof(int), 1, fp);
	::printf("训练集幻数：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, fp);
	::printf("训练集数量：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, fp);
	::printf("训练集高度：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, fp);
	::printf("训练集宽度：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, tp);
	::printf("标签幻数：%d\n", ReverseInt(rdint));
	::fread(&rdint, sizeof(int), 1, tp);
	::printf("标签数量：%d\n", ReverseInt(rdint));
	unsigned char* res = new unsigned char[28 * 28];
	float** X = apply2(28, 28);
	unsigned char biaoqian;
	Vector2 t2828 = Vector2(28, 28);
	for (int i = 0; i < 10; i++)
	{
		::fread(res, sizeof(unsigned char), 28 * 28, fp);
		Toshape2(X, res, 28, 28);
		print(X, t2828);
		float* h = SGD(W1, W5, Wo, X);//带入神经网络
		int c = -1;
		for (int i = 0; i < 10; i++)
		{
			if (h[i] > 0.85)
			{
				c = i;
				break;
			}
		}
		::fread(&biaoqian, sizeof(unsigned char), 1, tp);
		::printf("正确结果应当为“%d”,      神经网络识别为“%d”   \n", biaoqian, c);
	}
}
void main(int argc, char** argv)
{
	//train();//请先调用这个训练，训练结束后就可以直接加载权重了
	if (argc > 1)
	{
		sb(argv[1]);
		getchar();
	}
}



#include"TP_NNW.h"
#include<iostream>
#pragma warning(disable:4996)
void Weight::apply(int H, int W)
{
	fz = true;
	this->len.height = H;
	this->len.width = W;
	this->WG = apply2(H, W);//申请内存
	for (int i = 0; i < H; i++)
		for (int j = 0; j < W; j++)
			this->WG[i][j] = Get_rand();//得到随机值
}

void Weight::apply(int H, int W, float(*def)())
{
	fz = true;
	this->len.height = H;
	this->len.width = W;
	this->WG = apply2(H, W);
	for (int i = 0; i < H; i++)
		for (int j = 0; j < W; j++)
			this->WG[i][j] = def();
}

Weight::~Weight()
{
	this->release();
}

Weight::Weight(int H/*高度*/, int W/*宽度*/)
{
	W = W <= 0 ? 1 : W;//防止出现0和负数
	H = H <= 0 ? 1 : H;//防止出现0和负数
	fz = true;
	this->apply(H, W);
}

Weight::Weight(int H/*高度*/, int W/*宽度*/, float(*def)())
{
	W = W <= 0 ? 1 : W;
	H = H <= 0 ? 1 : H;
	fz = true;
	this->apply(H, W, def);
}

void Weight::re(float* delta, float* inp, float alpha)
{
	for (int i = 0; i < this->len.height; i++)
	{
		for (int j = 0; j < this->len.width; j++)
			this->WG[i][j] += alpha * delta[i] * inp[j];
	}
}

void Weight::save(FILE* fp)
{
	for (int i = 0; i < this->len.height; i++)
		for (int j = 0; j < this->len.width; j++)
			fwrite(&this->WG[i][j], sizeof(float), 1, fp);
}

void Weight::load(FILE* fp)
{
	for (int i = 0; i < this->len.height; i++)
		for (int j = 0; j < this->len.width; j++)
			fread(&this->WG[i][j], sizeof(float), 1, fp);
}

void Weight::release()
{
	if (this->fz)
	{
		Free2(this->WG, this->len.height);
		//free(this->WG);
	}
	this->fz = false;
}
void Weight::operator >> (Weight& temp)
{
	temp.release();
	//free(temp.WG);
	temp.apply(this->len.height, this->len.width, zeros);
}
void Weight::operator+=(Weight& temp)
{
	for (int i = 0; i < this->len.height; i++)
		for (int j = 0; j < this->len.width; j++)
			this->WG[i][j] += temp.WG[i][j];
}

//void Weight::operator/=(int & temp)
//{
//	for (int i = 0; i < this->len.height; i++)
//		for (int j = 0; j < this->len.width; j++)
//			this->WG[i][j] /= temp;
//}

void Weight::operator/=(int temp)
{
	for (int i = 0; i < this->len.height; i++)
		for (int j = 0; j < this->len.width; j++)
			this->WG[i][j] /= temp;
}

void Weight::operator<<(Weight& temp)
{
	Free2(this->WG, this->len.height);
	this->len.height = temp.len.height;
	this->len.width = temp.len.width;
	this->WG = temp.WG;
}

void WD(Weight* WGS, int H, int W, int len)
{
	for (int i = 0; i < len; i++)
	{
		WGS[i].apply(H, W);
	}
}
void WD(Weight* WGS, int H, int W, int len, float(*def)())
{
	for (int i = 0; i < len; i++)
	{
		WGS[i].apply(H, W, def);
	}
}
float zeros()
{
	return 0;
}


void print(float* y, int y_len)
{
	for (int i = 0; i < y_len; i++)
	{
		printf("%0.2f ", y[i]);
		//printf("%d ", y[i]>0?1:0);
	}
	puts("");
}

void print(float* y, Vector2& vec)
{
	print(y, vec.height);
}

void print(float** y, Vector2& vec)
{
	for (int i = 0; i < vec.height; i++)
		print(y[i], vec.width);
}

void print(char* y, int y_len)
{
	for (int i = 0; i < y_len; i++)
	{
		printf("%d ", y[i]);
	}
	puts("");
}

void print(char** y, Vector2& vec)
{
	for (int i = 0; i < vec.height; i++)
		print(y[i], vec.width);
}

void print(Weight& w)
{
	print(w.WG, w.len);
}

void print(Weight* w, int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("\n第%d层\n", i + 1);
		print(w[i]);
	}
}


float** apply2(int H, int W)
{
	float** temp = (float**)malloc(sizeof(float**) * H);
	for (int i = 0; i < H; i++)
		temp[i] = (float*)malloc(sizeof(float*) * W);
	return temp;
}

float*** apply3(int P, int H/*高度*/, int W/*宽度*/)
{
	float*** temp = (float***)malloc(sizeof(float***) * P);
	for (int i = 0; i < P; i++)
		temp[i] = apply2(H, W);
	return temp;
}

char** apply2_char(int H, int W)
{
	char** temp = (char**)malloc(sizeof(float**) * H);
	for (int i = 0; i < H; i++)
		temp[i] = (char*)malloc(sizeof(float*) * W);
	return temp;
}
float ones()
{
	return 1;
}
float*** Conv(float** X, Vector2& inp, Vector2& out, Weight* W, int W_len)
{
	out.height = inp.height - W[0].len.height + 1;
	out.width = inp.width - W[0].len.width + 1;
	float*** temp = (float***)malloc(sizeof(float***) * W_len);
	for (int k = 0; k < W_len; k++)
		temp[k] = conv2(X, inp, W[k].WG, W[0].len);
	return temp;
}
float*** Pool(float*** y, Vector2& inp, int P, Vector2& out)
{
	int h = inp.height / 2, w = inp.width / 2;
	out.height = h;
	out.width = w;
	float*** temp = apply3(P, h, w);
	float** filter = apply2(2, 2);
	for (int i = 0; i < 2; i++)
		for (int j = 0; j < 2; j++)
			filter[i][j] = 0.25;
	for (int k = 0; k < P; k++)
	{
		Vector2 len;
		Vector2 t22 = Vector2(2, 2);
		float** img = conv2(y[k], inp, filter, t22, &len);
		for (int i = 0; i < h; i++)
			for (int j = 0; j < w; j++)
				temp[k][i][j] = img[i * 2][j * 2];
		Free2(img, len.height);
	}
	Free2(filter, 2);
	return temp;
}
float* apply1(int H)
{
	float* temp = (float*)malloc(sizeof(float*) * H);
	return temp;
}

char* apply1_char(int H)
{
	char* temp = (char*)malloc(sizeof(char*) * H);
	return temp;
}

float Get_rand()
{
	float temp = (float)(rand() % 10) / (float)10;
	return rand() % 2 == 0 ? temp : -temp;
}

float Sigmoid(float x)
{
	return 1 / (1 + exp(-x));
}

float* Sigmoid(float* x, Weight& w)
{
	return Sigmoid(x, w.len.height);
}

float* Sigmoid(float* x, int height)
{
	float* y = (float*)malloc(sizeof(float*) * height);
	for (int i = 0; i < height; i++)
		y[i] = Sigmoid(x[i]);
	return y;
}

float ReLU(float x)
{
	return x > 0 ? x : 0;
}

float* ReLU(float* x, Weight& w)
{
	return ReLU(x, w.len.height);
}

float* ReLU(float* x, int height)
{
	float* y = (float*)malloc(sizeof(float*) * height);
	for (int i = 0; i < height; i++)
		y[i] = ReLU(x[i]);
	return y;
}

float* Softmax(float* x, Weight& w)
{
	return Softmax(x, w.len.height);
}

float dsigmoid(float x)
{
	return x * (1 - x);
}

float* Softmax(float* x, int height)
{
	float* t = new float[height];
	float* ex = new float[height];
	float sum = 0;
	for (int i = 0; i < height; i++)
	{
		ex[i] = exp(x[i]);
		sum += ex[i];
	}
	for (int i = 0; i < height; i++)
	{
		t[i] = ex[i] / sum;
	}
	delete ex;
	return t;
}

float* FXCB_err(Weight& w, float* delta)
{
	float* temp = (float*)malloc(sizeof(float*) * w.len.width);
	for (int i = 0; i < w.len.width; i++)
		temp[i] = 0;
	for (int i = 0; i < w.len.width; i++)
		for (int j = 0; j < w.len.height; j++)
			temp[i] += w.WG[j][i] * delta[j];
	return temp;
}

float* Delta1(float* y, float* e, Weight& w)
{
	float* temp = (float*)malloc(sizeof(float*) * w.len.height);
	for (int i = 0; i < w.len.height; i++)
		temp[i] = y[i] * (1 - y[i]) * e[i];
	return temp;
}

float* Delta2(float* v, float* e, Weight& w)
{
	float* temp = (float*)malloc(sizeof(float*) * w.len.height);
	for (int i = 0; i < w.len.height; i++)
		temp[i] = v[i] > 0 ? e[i] : 0;
	return temp;
}

float* dot(Weight& W, float* inp, int* len)
{
	float* temp = (float*)malloc(sizeof(float*) * W.len.height);
	for (int i = 0; i < W.len.height; i++)
		temp[i] = 0;
	for (int i = 0; i < W.len.height; i++)
	{
		for (int j = 0; j < W.len.width; j++)
			temp[i] += (W.WG[i][j] * inp[j]);
	}
	if (len != NULL)
		*len = W.len.height;
	return temp;
}

char* randperm(int max, int count)
{
	char* temp = new char[count] {0};
	for (int i = 0; i < count; i++)
	{
		while (1)
		{
			char t = rand() % max;
			bool nothave = true;
			for (int j = 0; j < i; j++)
				if (t == temp[j])
				{
					nothave = false;
					break;
				}
			if (nothave)
			{
				temp[i] = t;
				break;
			}
		}
	}
	return temp;
}

void Dropout(float* y, float ratio, Weight& w)
{
	float* ym = new float[w.len.height] {0};
	float round = w.len.height * (1 - ratio);
	int num = (round - (float)(int)round >= 0.5f ? (int)round + 1 : (int)round);
	char* idx = randperm(w.len.height, num);
	for (int i = 0; i < num; i++)
	{
		ym[idx[i]] = (1 / (1 - ratio));
	}
	for (int i = 0; i < w.len.height; i++)
	{
		y[i] *= ym[i];
	}
	delete idx;
	delete ym;
}

float** conv2(float** x, Vector2& x_len, float** fiter, Vector2& fiter_len, Vector2* out_len, int flag, int distance, int fill)
{
	switch (flag)
	{
	case Valid:return VALID(x, x_len.height, x_len.width, fiter, fiter_len.height, fiter_len.width, distance, out_len);
	case Same:return SAME(x, x_len.height, x_len.width, fiter, fiter_len.height, fiter_len.width, distance, fill, out_len);
	}
	return nullptr;
}

float** VALID(float** x, int x_h, int x_w, float** fiter, int fiter_h, int fiter_w, int distance, Vector2* out_len)
{
	int h = VALID_out_len(x_h, fiter_h, distance);
	int w = VALID_out_len(x_w, fiter_w, distance);
	float** temp = apply2(h, w);
	float** t = fiter;
	if (out_len != NULL)
	{
		out_len->height = h;
		out_len->width = w;
	}
	for (int i = 0; i < x_h + 1 - fiter_h; i += distance)
		for (int j = 0; j < x_w + 1 - fiter_w; j += distance)
		{
			float count = 0;
			for (int n = i; n < i + fiter_h; n++)
				for (int m = j; m < j + fiter_w; m++)
				{
					if (n >= x_h || m >= x_w)
						continue;
					count += (x[n][m] * t[n - i][m - j]);
				}
			temp[(i / distance)][(j / distance)] = count;
		}
	//free(t);
	return temp;
}

float** SAME(float** x, int x_h, int x_w, float** fiter, int fiter_h, int fiter_w, int distance, int fill, Vector2* out_len)
{
	return nullptr;
}

int VALID_out_len(int x_len, int fiter_len, int distance)
{
	float temp = (float)(x_len - fiter_len) / (float)distance;
	int t = temp - (int)((float)temp) >= 0.5 ? (int)temp + 1 : (int)temp;
	t++;
	return t;
}

void show_Weight(Weight& W)
{
	for (int i = 0; i < W.len.height; i++)
	{
		for (int j = 0; j < W.len.width; j++)
		{
			printf("%0.3f ", W.WG[i][j]);
		}
		puts("");
	}
}
void rot90(Weight& x)
{
	int h = x.len.width, w = x.len.height;
	x.WG = rot90(x.WG, x.len, true);
	x.len.width = w;
	x.len.height = h;
}
float** rot90(float** x, Vector2& x_len, bool release)
{
	float** temp = apply2(x_len.width, x_len.height);
	for (int i = 0; i < x_len.height; i++)
		for (int j = 0; j < x_len.width; j++)
		{
			temp[x_len.width - 1 - j][i] = x[i][j];
		}
	if (release)
	{
		Free2(x, x_len.height);
		//free(x);
	}
	return temp;
}

float** rot180(float** x, Vector2& x_len, bool release)
{
	float** temp = apply2(x_len.height, x_len.width);
	for (int i = 0; i < x_len.height; i++)
	{
		for (int j = 0; j < x_len.width; j++)
		{
			temp[x_len.height - 1 - i][x_len.width - 1 - j] = x[i][j];
		}
	}
	if (release)
	{
		Free2(x, x_len.height);
		//free(x);
	}
	return temp;
}
void ResizeCImage(CImage& image, int newWidth, int newHeight) {
	// 创建新的CImage对象，并设置大小
	CImage resizedImage;
	resizedImage.Create(newWidth, newHeight, image.GetBPP());

	// 使用Gdiplus::Graphics将原始图像绘制到新图像上，并进行缩放
	SetStretchBltMode(resizedImage.GetDC(), HALFTONE);
	image.StretchBlt(resizedImage.GetDC(), 0, 0, newWidth, newHeight);

	// 完成绘制后，释放新图像的设备上下文
	resizedImage.ReleaseDC();

	// 将结果拷贝回原始的CImage对象
	image.Destroy();
	image.Attach(resizedImage.Detach());
	resizedImage.Destroy();
}
float** Get_data_by_Mat(char* filepath, Vector2& out_len)
{
	CImage mat;// = cv::imread(filepath, 0);
	//cv::resize(mat, mat, cv::Size(28, 28));
	mat.Load(filepath);
	ResizeCImage(mat, 28, 28);
	/*cv::imshow("tt", mat);
	cv::waitKey(0);*/
	out_len.height = mat.GetHeight();
	out_len.width = mat.GetWidth();
	float** temp = apply2(mat.GetHeight(), mat.GetWidth());
	unsigned char* rgb = (unsigned char*)mat.GetBits();
	int pitch = mat.GetPitch();
	int hui = 0;
	int XS = mat.GetBPP()/8;
	for (int i = 0; i < out_len.height; i++)
		for (int j = 0; j < out_len.width; j++)
		{
			hui = 0;
			for (int kkk = 0; kkk < 3; kkk++)
			{
				hui += *(rgb + (j * XS) + (i * pitch) + kkk);
			}
			hui /= 3;
			temp[i][j] = ((float)hui / (float)255);
			//temp[i][j] = 1 - temp[i][j];
		}
	mat.Destroy();
	return temp;
}

char** Get_data_by_Mat_char(char* filepath, Vector2& out_len, int threshold)
{
	CImage mat;
	mat.Load(filepath);
	//cv::Mat mat = cv::imread(filepath, 0);
	out_len.height = mat.GetHeight();
	out_len.width = mat.GetWidth();
	char** temp = apply2_char(out_len.height, out_len.width);
	unsigned char* rgb = (unsigned char*)mat.GetBits();
	int pitch = mat.GetPitch();
	int hui = 0;
	int XS = mat.GetBPP() / 8;
	for (int i = 0; i < out_len.height; i++)
		for (int j = 0; j < out_len.width; j++)
		{
			hui = 0;
			for (int kkk = 0; kkk < 3; kkk++)
			{
				hui += *(rgb + (j * XS) + (i * pitch) + kkk);
			}
			hui /= 3;
			temp[i][j] = hui > threshold ? 0 : 1;
		}
	mat.Destroy();
	return temp;
}

void Get_data_by_Mat(char* filepath, Weight& w)
{
	w.WG = Get_data_by_Mat(filepath, w.len);
}

Weight Get_data_by_Mat(char* filepath)
{
	Weight temp;
	Get_data_by_Mat(filepath, temp);
	return temp;
}

Vector2::Vector2()
{
	this->height = 0;
	this->width = 0;
}

Vector2::Vector2(char height, int width)
{
	this->height = height;
	this->width = width;
}

XML::XML(FILE* fp, char* name, int layer)
{
	this->fp = fp;
	this->name = name;
	this->layer = layer;
}

void XML::showchild()
{
	char reader[500];
	while (fgets(reader, 500, this->fp))
	{
		int len = strlen(reader);
		int lay = 0;
		for (; lay < len; lay++)
		{
			if (reader[lay] != '\t')break;
		}
		if (lay == this->layer)
		{
			if (reader[lay + 1] == '/')continue;
			char show[500];
			memset(show, 0, 500);
			for (int i = lay + 1; i < len - 2; i++)
			{
				if (reader[i] == '>')break;
				show[i - lay - 1] = reader[i];
			}
			puts(show);
		}
	}
	fseek(this->fp, 0, 0);
}

void bit::operator=(int x)
{
	this->B = x;
}

float* reshape(float** x, int h, int w)
{
	float* temp = (float*)malloc(sizeof(float*) * w * h);
	int count = 0;
	for (int i = 0; i < h; i++)
		for (int j = 0; j < w; j++)
		{
			temp[count++] = x[i][j];
		}
	return temp;
}

float* reshape(float** x, Vector2& x_len)
{
	return reshape(x, x_len.height, x_len.width);
}

float* reshape(float*** x, Vector2& x_len, int P, bool releace)
{
	float* temp = apply1(x_len.height * x_len.width * P);
	int c = 0;
	for (int i = 0; i < P; i++)
		for (int n = 0; n < x_len.height; n++)
			for (int m = 0; m < x_len.width; m++)
				temp[c++] = x[i][n][m];
	if (releace)
		Free3(x, P, x_len.height);
	//free(x);
	return temp;
}

int* bList(int distance, int max, int* out_len)
{
	int num = (max % distance != 0);
	int t = (int)(max / distance);
	t += num;
	if (out_len != NULL)
		*out_len = t;
	int* out = (int*)malloc(sizeof(int*) * t);
	for (int i = 0; i < t; i++)
	{
		out[i] = i * distance;
	}
	return out;
}

void Free2(float** x, int h)
{
	for (int i = 0; i < h; i++)
		free(x[i]);
	free(x);
}

void Free3(float*** x, int p, int h)
{
	for (int i = 0; i < p; i++)
		for (int j = 0; j < h; j++)
			free(x[i][j]);
	for (int i = 0; i < p; i++)
		free(x[i]);
	free(x);
}

void kron(float** out, Vector2& out_len, float** inp, Vector2& inp_len, float** filter, Vector2& filter_len)
{
	for (int i = 0; i < inp_len.height; i++)
		for (int j = 0; j < inp_len.width; j++)
		{
			for (int n = i * 2; n < out_len.height && n < ((i * 2) + filter_len.height); n++)
				for (int m = (j * 2); m < ((j * 2) + filter_len.width) && m < out_len.width; m++)
				{
					out[n][m] = inp[i][j] * filter[n - (i * 2)][m - (j * 2)] * 0.25;
				}
		}
}

char** mnist::Toshape2(char* x, int h, int w)
{
	char** temp = apply2_char(h, w);
	int c = 0;
	for (int i = 0; i < h; i++)
		for (int j = 0; j < w; j++)
			temp[i][j] = x[c++];
	return temp;
}

char** mnist::Toshape2(char* x, Vector2& x_len)
{
	return mnist::Toshape2(x, x_len.height, x_len.width);
}

void mnist::Toshape2(char** out, char* x, int h, int w)
{
	int c = 0;
	for (int i = 0; i < h; i++)
		for (int j = 0; j < w; j++)
			out[i][j] = x[c++];
}

void mnist::Toshape2(char** out, char* x, Vector2& x_len)
{
	mnist::Toshape2(out, x, x_len.height, x_len.width);
}

float** mnist::Toshape2_F(char* x, int h, int w)
{
	float** temp = apply2(h, w);
	int c = 0;
	for (int i = 0; i < h; i++)
		for (int j = 0; j < w; j++)
			temp[i][j] = ((float)x[c++] / (float)255);
	return temp;
}

float** mnist::Toshape2_F(char* x, Vector2& x_len)
{
	return mnist::Toshape2_F(x, x_len.height, x_len.width);
}

void mnist::Toshape2(float** out, char* x, int h, int w)
{
	int c = 0;
	for (int i = 0; i < h; i++)
		for (int j = 0; j < w; j++)
			out[i][j] = ((float)x[c++] / (float)255);
}

void mnist::Toshape2(float** out, char* x, Vector2& x_len)
{
	mnist::Toshape2(out, x, x_len.height, x_len.width);
}

void mnist::Toshape2(float** out, unsigned char* x, int h, int w)
{
	int c = 0;
	for (int i = 0; i < h; i++)
		for (int j = 0; j < w; j++)
		{
			out[i][j] = ((float)x[c++] / (float)255);
		}
}

void mnist::Toshape2(float** out, unsigned char* x, Vector2& x_len)
{
	mnist::Toshape2(out, x, x_len.height, x_len.width);
}

float*** mnist::Toshape3(float* x, int P, Vector2& x_len)
{
	float*** temp = apply3(P, x_len.height, x_len.width);
	int c = 0;
	for (int i = 0; i < P; i++)
		for (int j = 0; j < x_len.height; j++)
			for (int n = 0; n < x_len.width; n++)
				temp[i][j][n] = x[c++];
	return temp;
}

int mnist::ReverseInt(int i)
{
	unsigned char ch1, ch2, ch3, ch4;
	ch1 = i & 255;
	ch2 = (i >> 8) & 255;
	ch3 = (i >> 16) & 255;
	ch4 = (i >> 24) & 255;
	return((int)ch1 << 24) + ((int)ch2 << 16) + ((int)ch3 << 8) + ch4;
}



#pragma once
#include<Windows.h>
#include<atlimage.h>
#define ALPHA 0.01
#define BETA 0.95
#define RATIO 0.2
void ResizeCImage(CImage& image, int newWidth, int newHeight);
struct bit
{
	unsigned B : 1;
	void operator=(int x);
};
enum Conv_flag
{
	Valid = 0,
	Same = 1
};
struct Vector2 {
	int height, width;
	Vector2();
	Vector2(char height, int width);
};
class Weight
{
private:
	void apply(int H/*高度*/, int W/*宽度*/);
	void apply(int H/*高度*/, int W/*宽度*/, float(*def)());
public:
	bool fz;
	Vector2 len;
	float** WG;
	~Weight();
	Weight() { fz = false; }
	Weight(int H/*高度*/, int W/*宽度*/);
	Weight(int H/*高度*/, int W/*宽度*/, float (*def)());
	void re(float* delta, float* inp, float alpha = ALPHA);
	void save(FILE* fp);
	void load(FILE* fp);
	void release();
	void operator>>(Weight& temp);
	void operator+=(Weight& temp);
	//void operator/=(int &temp);
	void operator/=(int temp);
	void operator<<(Weight& temp);
	void friend WD(Weight* WGS, int H, int W, int len);
	void friend WD(Weight* WGS, int H, int W, int len, float(*def)());
};
float zeros();
float ones();
float*** Pool(float*** y, Vector2& inp, int P, Vector2& out);//池化
float*** Conv(float** X, Vector2& inp, Vector2& out, Weight* W, int W_len);//卷积
void print(float* y, int y_len = 1);
void print(float* y, Vector2& vec);
void print(float** y, Vector2& vec);
void print(char* y, int y_len = 1);
void print(char** y, Vector2& vec);
void print(Weight& w);
void print(Weight* w, int len = 1);
float** apply2(int H/*高度*/, int W/*宽度*/);
float*** apply3(int P, int H/*高度*/, int W/*宽度*/);
char** apply2_char(int H/*高度*/, int W/*宽度*/);
float* apply1(int H);
char* apply1_char(int H);
float Get_rand();
float Sigmoid(float x);
float* Sigmoid(float* x, Weight& w);
float* Sigmoid(float* x, int height);
float ReLU(float x);
float* ReLU(float* x, Weight& w);
float* ReLU(float* x, int height);
float* Softmax(float* x, Weight& w);
float dsigmoid(float x);
float* Softmax(float* x, int height);
float* FXCB_err(Weight& w, float* delta);
float* Delta1(float* y, float* e, Weight& w);
float* Delta2(float* v, float* e, Weight& w);
float* dot(Weight& W/*权重*/, float* inp/*输入数据*/, int* len = NULL);
char* randperm(int max, int count);
void Dropout(float* y, float ratio, Weight& w);
float** conv2(float** x, Vector2& x_len, float** fiter, Vector2& fiter_len,
	Vector2* out_len = NULL, int flag = Valid, int distance = 1, int fill = 0);
float** VALID(float** x, int x_h, int x_w, float** fiter, int fiter_h,
	int fiter_w, int distance, Vector2* out_len = NULL);
float** SAME(float** x, int x_h, int x_w, float** fiter, int fiter_h,
	int fiter_w, int distance, int fill, Vector2* out_len = NULL);
int VALID_out_len(int x_len, int fiter_len, int distance);
void show_Weight(Weight& W);
void rot90(Weight& x);
float** rot90(float** x, Vector2& x_len, bool release = false);
float** rot180(float** x, Vector2& x_len, bool release = false);
float** Get_data_by_Mat(char* filepath, Vector2& out_len);
char** Get_data_by_Mat_char(char* filepath, Vector2& out_len, int threshold = 127);
void Get_data_by_Mat(char* filepath, Weight& w);
Weight Get_data_by_Mat(char* filepath);
float* reshape(float** x, int h, int w);
float* reshape(float** x, Vector2& x_len);
float* reshape(float*** x, Vector2& x_len, int P, bool releace = false);
namespace mnist
{
	char** Toshape2(char* x, int h, int w);
	char** Toshape2(char* x, Vector2& x_len);
	void Toshape2(char** out, char* x, int h, int w);
	void Toshape2(char** out, char* x, Vector2& x_len);
	float** Toshape2_F(char* x, int h, int w);
	float** Toshape2_F(char* x, Vector2& x_len);
	void Toshape2(float** out, char* x, int h, int w);
	void Toshape2(float** out, char* x, Vector2& x_len);
	void Toshape2(float** out, unsigned char* x, int h, int w);
	void Toshape2(float** out, unsigned char* x, Vector2& x_len);
	float*** Toshape3(float* x, int P, Vector2& x_len);
	int ReverseInt(int i);
}
struct XML
{
	char* name;
	FILE* fp;
	int layer;
	XML(FILE* fp, char* name, int layer);
	void showchild();
};
template<class T>
class hot_one
{
	bool fz;
public:
	T* one;
	int num;
	int count;
	hot_one() { this->fz = false; }
	hot_one(int type_num, int set_num = 0)
	{
		type_num = type_num <= 0 ? 1 : type_num;
		if (set_num >= type_num)
			set_num = 0;
		this->count = type_num;
		this->fz = true;
		this->num = set_num;
		this->one = new T[type_num]{ 0 };
		this->one[set_num] = 1;
	}
	void re(int set_num)
	{
		this->one[num] = 0;
		this->num = set_num;
		this->one[this->num] = 1;
	}
	void release()
	{
		if (this->fz)delete one;
		this->fz = false;
	}
	~hot_one()
	{
		this->release();
	}
};
int* bList(int distance, int max, int* out_len);
void Free2(float** x, int h);
void Free3(float*** x, int p, int h);
void kron(float** out, Vector2& out_len, float** inp, Vector2& inp_len, float** filter,
	Vector2& filter_len);
万能的小裴同学
关注
  • 4
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【深度学习】从现代C++中的开始：卷积
gongdiwudu的专栏
07-27 3723
本文，让我们通过使用 2D 卷积实现实际编码深度学习模型来开始我们的道路。让我们开始吧。
C++ 中的卷积神经网络 (CNN)
小白学视觉
06-15 3385
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达 有很多卷积神经网络文章解释了 CNN 是什么以及它的用途是什么，而本文将用 C++ 编写一个 CN...
卷积神经网络简单实现（C++）
07-01
卷积神经网络的简单实现 开发语言：C++ 便宜环境：Ubuntu 16.04 依赖库eigen3
卷积神经网络(CNN)详解与代码实现
shenyuan12的专栏
08-24 1万+
目录 1.应用场景 2.卷积神经网络结构 2.1 卷积（convelution） 2.2 Relu激活函数 2.3 池化（pool） 2.4 全连接（full connection） 2.5 损失函数（softmax_loss） 2.6 前向传播（forward propagation） 2.7 反向传播（backford propagation） 2.8 随机梯度下降（sgd_momentum） 3.代码实现流程图以及介绍 4.代码实现（python3.6） 5....
C++实现卷积运算
hanshuning的专栏
12-25 4260
清理磁盘，看到了几年前的代码 #include<iostream> using namespace std; void main() { //输入卷积矩阵 int row1 = 3, col1 = 3; int a[3][3]; //cout<<"输入卷积矩阵的行数："; //cin>>row1; //cout<<"输入卷积矩阵的列数："; //cin>>col1; cout << "输入卷积矩阵：" <<
基于C++实现卷积神经网络
10-14
基于C++底层代码构建，初步实现卷积神经网络
神经网络文章收藏
Escape the bug的博客
11-18 172
U-net网络
C++ 卷积神经网络
qq_42877866的博客
01-03 2702
C++卷积神经网络
用C语言实现一个简单的卷积神经网络
Java、C语言、嵌入式开发，计算机科学与技术专业（海南大学）
05-29 1032
上述代码演示了一个简单的卷积神经网络模型，创建了一个包含3个过滤器（filters）的模型，每个过滤器的大小为3x3。然后给定一个5x5的输入矩阵，通过前向传播计算了输出矩阵。最后打印了输出矩阵。请注意，此代码仅用于演示目的，实际的卷积神经网络模型可能需要更复杂的结构和算法来实现。
CNN_MNist_solar72q_deeplearning_C++卷积神经网络_cnn网络c实现_卷积神经网络_
10-02
卷积神经网络是一类包含卷积计算且具有深度结构的前馈神经网络，是深度学习（deep learning）的代表算法之一。这是C++实现的卷积神经网络源码，识别手写阿位伯数字（以MNIST集为例），很容易改为识别汽车牌照的CN版本源码。
卷积神经网络
12-19
卷积神经网络 模式识别
卷积神经网络C++实现
08-07
卷积神经网络的C++实现，附实现用的文档资源链接。 架构好，有注释，minitest手写数据集上的识别率0.98 可供参考
简单卷积神经网络的C++实现及一些探讨
qq_42181309的博客
03-16 1629
Contents 前言 2 神经网络算法理解 3 整体思想 3 特征向量 3 激活单元 3 行向量与列向量的意义 4 损失函数与梯度 4 激活单元的缺陷 5 卷积层算法理解 6 为什么要引入卷积 6 一些超级参数 6 接入神经网络 7 部分具体实现 7 大体步骤 7 关于卷积运层反向传播的的一些探讨 7 化卷积运算为矩阵乘法 7 对b的处理 8 具体网络模型 8 附录 9 前言 选的题目为第二个汉字识别。原先计划实现的神经网络为卷积神经网络（打算采用卷积神.
CNN基本原理及Python实现
热门推荐
vinojie的博客
05-18 1万+
CNN基本原理，和Python的简单实现过程
图像处理之卷积模式及C++实现
程序员深度学习
10-28 1719
1. 卷积的三种模式 深度学习框架中通常会实现三种不同的卷积模式，分别是 SAME、VALID、FULL。这三种模式的核心区别在于卷积核进行卷积操作的移动区域不同，进而导致输出的尺寸不同。我们以一个例子来看这三种模式的区别，输入图片的尺寸是5x5 ，卷积核尺寸是 3x3 ，stride 取 1。 1.1 FULL 模式 FULL 模式下卷积核从与输入有一个点的相交的地方就开始卷积。如下图所示，蓝框的位置就是卷积核第一个卷积的地方，灰色部分是为了卷积能够正常进行的 padding（一般填 0）。因此 FUL.
使用C++编写卷积神经网络（一）
qq_30883339的博客
05-23 7379
鉴于用python写神经网络、卷积神经网络的话，不利于框架直接用numpy等来完成，速度实在是慢的吓人，所以改用c++来写。c++的话什么操作基本都要自己定义。由于卷积神经网络主要针对图像类，故最好定义一个适用于图像类的矩阵类，我这边使用了网上一个开源的用c++写好的卷积神经网络，使用了里面定义好的矩阵类，如下。这个类个人觉得非常好用，故写成博客，收藏一波，方便以后使用时候查找。 首先导入需要的模...
Windows Opencl clEnqueueReadBuffer()与clEnqueueWriteBuffer()函数
qq_42877866的博客
07-25 4495
Windows Opencl clEnqueueReadBuffer()与clEnqueueWriteBuffer()函数详细解析 Reading, Writing and Copying Buffer Objects 以下函数将命令从缓冲区对象读入主机内存或从主机内存写入缓冲区对象。 clEnqueueReadBuffer函数原型 cl_int clEnqueueReadBuffer(cl_command_queue command_queue, cl_mem
Windows Opencl clSetKernelArg()函数
qq_42877866的博客
07-20 3403
Windows Opencl clSetKernelArg()函数详细解析 Setting Kernel Arguments 函数原型 cl_int clSetKernelArg(cl_kernel kernel, cl_uint arg_index, size_t arg_size, const void *arg_value) clSetKernelArg()用于为内核的特
C++ 二叉树的赋值与遍历
qq_42877866的博客
07-19 3380
C++ 二叉树的赋值与遍历 二叉树主要是对链表，递归函数的灵活运用 下面是简单的二叉树赋值和遍历的代码 main.cpp #include<iostream> struct Tree//二叉树结构 { int Root;//根节点，用来保存数据 Tree *Rbranch;//右树枝 Tree *Lbranch;//左树枝 }; void setvalue(Tree *tree)//二叉树赋值 { printf("请设置数值："); scanf("%d",&(tree-&g
c++ 卷积神经网络 图像
最新发布
12-03
卷积神经网络是一种深度学习模型，它被广泛应用于图像识别和分类任务中。它的核心思想是对输入的图像进行多次卷积操作和池化操作，从而提取图像中的特征信息。卷积操作可以有效地捕捉到图像中的局部特征，而池化操作可以降低特征的维度，并且具有抗干扰能力，能够保持对图像中特征的抽象感知。通过多次的卷积和池化操作，网络可以逐渐地提取出图像的高级特征，最终将这些特征传递给全连接层进行分类。 在卷积神经网络中，通常由若干个卷积层、池化层和全连接层组成，其中卷积层用于提取图像特征，池化层用于降维和抗干扰，全连接层则用于分类预测。整个网络的结构可以通过调整不同的超参数和层数来进行优化，以提高图像识别和分类的准确率。 卷积神经网络在图像识别、人脸识别、目标检测等领域都取得了显著的成果，它不仅可以处理静态图像，还可以处理视频、3D图像等多种形式的数据。同时，卷积神经网络也可以通过迁移学习和微调来适应不同的任务和数据集，具有很好的通用性和扩展性。 总的来说，卷积神经网络通过卷积和池化操作有效地提取图像特征，通过全连接层进行分类预测，是一种非常有效的图像识别和分类模型。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值